[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  
   4  
   5  
   6  /**
   7  *
   8  * soapclient2 higher level class for easy usage.
   9  *
  10  * usage:
  11  *
  12  * // instantiate client with server info
  13  * $soapclient2 = new soapclient2( string path [ ,boolean wsdl] );
  14  *
  15  * // call method, get results
  16  * echo $soapclient2->call( string methodname [ ,array parameters] );
  17  *
  18  * // bye bye client
  19  * unset($soapclient2);
  20  *
  21  * @author   Dietrich Ayala <[email protected]>
  22  * @version  $Id: class.soapclient2.php,v 1.52 2005/07/27 19:24:42 snichol Exp $
  23  * @access   public
  24  */
  25  class soapclient2 extends nusoap_base  {
  26  
  27      var $username = '';
  28      var $password = '';
  29      var $authtype = '';
  30      var $certRequest = array();
  31      var $requestHeaders = false;    // SOAP headers in request (text)
  32      var $responseHeaders = '';        // SOAP headers from response (incomplete namespace resolution) (text)
  33      var $document = '';                // SOAP body response portion (incomplete namespace resolution) (text)
  34      var $endpoint;
  35      var $forceEndpoint = '';        // overrides WSDL endpoint
  36      var $proxyhost = '';
  37      var $proxyport = '';
  38      var $proxyusername = '';
  39      var $proxypassword = '';
  40      var $xml_encoding = '';            // character set encoding of incoming (response) messages
  41      var $http_encoding = false;
  42      var $timeout = 0;                // HTTP connection timeout
  43      var $response_timeout = 30;        // HTTP response timeout
  44      var $endpointType = '';            // soap|wsdl, empty for WSDL initialization error
  45      var $persistentConnection = false;
  46      var $defaultRpcParams = false;    // This is no longer used
  47      var $request = '';                // HTTP request
  48      var $response = '';                // HTTP response
  49      var $responseData = '';            // SOAP payload of response
  50      var $cookies = array();            // Cookies from response or for request
  51      var $decode_utf8 = true;        // toggles whether the parser decodes element content w/ utf8_decode()
  52      var $operations = array();        // WSDL operations, empty for WSDL initialization error
  53      
  54      /*
  55       * fault related variables
  56       */
  57      /**
  58       * @var      fault
  59       * @access   public
  60       */
  61      var $fault;
  62      /**
  63       * @var      faultcode
  64       * @access   public
  65       */
  66      var $faultcode;
  67      /**
  68       * @var      faultstring
  69       * @access   public
  70       */
  71      var $faultstring;
  72      /**
  73       * @var      faultdetail
  74       * @access   public
  75       */
  76      var $faultdetail;
  77  
  78      /**
  79      * constructor
  80      *
  81      * @param    mixed $endpoint SOAP server or WSDL URL (string), or wsdl instance (object)
  82      * @param    bool $wsdl optional, set to true if using WSDL
  83      * @param    int $portName optional portName in WSDL document
  84      * @param    string $proxyhost
  85      * @param    string $proxyport
  86      * @param    string $proxyusername
  87      * @param    string $proxypassword
  88      * @param    integer $timeout set the connection timeout
  89      * @param    integer $response_timeout set the response timeout
  90      * @access   public
  91      */
  92  	function soapclient2($endpoint,$wsdl = false,$proxyhost = false,$proxyport = false,$proxyusername = false, $proxypassword = false, $timeout = 0, $response_timeout = 30){
  93          parent::nusoap_base();
  94          $this->endpoint = $endpoint;
  95          $this->proxyhost = $proxyhost;
  96          $this->proxyport = $proxyport;
  97          $this->proxyusername = $proxyusername;
  98          $this->proxypassword = $proxypassword;
  99          $this->timeout = $timeout;
 100          $this->response_timeout = $response_timeout;
 101  
 102          // make values
 103          if($wsdl){
 104              if (is_object($endpoint) && (get_class($endpoint) == 'wsdl')) {
 105                  $this->wsdl = $endpoint;
 106                  $this->endpoint = $this->wsdl->wsdl;
 107                  $this->wsdlFile = $this->endpoint;
 108                  $this->debug('existing wsdl instance created from ' . $this->endpoint);
 109              } else {
 110                  $this->wsdlFile = $this->endpoint;
 111                  
 112                  // instantiate wsdl object and parse wsdl file
 113                  $this->debug('instantiating wsdl class with doc: '.$endpoint);
 114                  $this->wsdl =& new wsdl($this->wsdlFile,$this->proxyhost,$this->proxyport,$this->proxyusername,$this->proxypassword,$this->timeout,$this->response_timeout);
 115              }
 116              $this->appendDebug($this->wsdl->getDebug());
 117              $this->wsdl->clearDebug();
 118              // catch errors
 119              if($errstr = $this->wsdl->getError()){
 120                  $this->debug('got wsdl error: '.$errstr);
 121                  $this->setError('wsdl error: '.$errstr);
 122              } elseif($this->operations = $this->wsdl->getOperations()){
 123                  $this->debug( 'got '.count($this->operations).' operations from wsdl '.$this->wsdlFile);
 124                  $this->endpointType = 'wsdl';
 125              } else {
 126                  $this->debug( 'getOperations returned false');
 127                  $this->setError('no operations defined in the WSDL document!');
 128              }
 129          } else {
 130              $this->debug("instantiate SOAP with endpoint at $endpoint");
 131              $this->endpointType = 'soap';
 132          }
 133      }
 134  
 135      /**
 136      * calls method, returns PHP native type
 137      *
 138      * @param    string $method SOAP server URL or path
 139      * @param    mixed $params An array, associative or simple, of the parameters
 140      *                          for the method call, or a string that is the XML
 141      *                          for the call.  For rpc style, this call will
 142      *                          wrap the XML in a tag named after the method, as
 143      *                          well as the SOAP Envelope and Body.  For document
 144      *                          style, this will only wrap with the Envelope and Body.
 145      *                          IMPORTANT: when using an array with document style,
 146      *                          in which case there
 147      *                         is really one parameter, the root of the fragment
 148      *                         used in the call, which encloses what programmers
 149      *                         normally think of parameters.  A parameter array
 150      *                         *must* include the wrapper.
 151      * @param    string $namespace optional method namespace (WSDL can override)
 152      * @param    string $soapAction optional SOAPAction value (WSDL can override)
 153      * @param    mixed $headers optional string of XML with SOAP header content, or array of soapval objects for SOAP headers
 154      * @param    boolean $rpcParams optional (no longer used)
 155      * @param    string    $style optional (rpc|document) the style to use when serializing parameters (WSDL can override)
 156      * @param    string    $use optional (encoded|literal) the use when serializing parameters (WSDL can override)
 157      * @return    mixed    response from SOAP call
 158      * @access   public
 159      */
 160  	function call($operation,$params=array(),$namespace='http://tempuri.org',$soapAction='',$headers=false,$rpcParams=null,$style='rpc',$use='encoded'){
 161          $this->operation = $operation;
 162          $this->fault = false;
 163          $this->setError('');
 164          $this->request = '';
 165          $this->response = '';
 166          $this->responseData = '';
 167          $this->faultstring = '';
 168          $this->faultcode = '';
 169          $this->opData = array();
 170          
 171          $this->debug("call: operation=$operation, namespace=$namespace, soapAction=$soapAction, rpcParams=$rpcParams, style=$style, use=$use, endpointType=$this->endpointType");
 172          $this->appendDebug('params=' . $this->varDump($params));
 173          $this->appendDebug('headers=' . $this->varDump($headers));
 174          if ($headers) {
 175              $this->requestHeaders = $headers;
 176          }
 177          // serialize parameters
 178          if($this->endpointType == 'wsdl' && $opData = $this->getOperationData($operation)){
 179              // use WSDL for operation
 180              $this->opData = $opData;
 181              $this->debug("found operation");
 182              $this->appendDebug('opData=' . $this->varDump($opData));
 183              if (isset($opData['soapAction'])) {
 184                  $soapAction = $opData['soapAction'];
 185              }
 186              if (! $this->forceEndpoint) {
 187                  $this->endpoint = $opData['endpoint'];
 188              } else {
 189                  $this->endpoint = $this->forceEndpoint;
 190              }
 191              $namespace = isset($opData['input']['namespace']) ? $opData['input']['namespace'] :    $namespace;
 192              $style = $opData['style'];
 193              $use = $opData['input']['use'];
 194              // add ns to ns array
 195              if($namespace != '' && !isset($this->wsdl->namespaces[$namespace])){
 196                  $nsPrefix = 'ns' . rand(1000, 9999);
 197                  $this->wsdl->namespaces[$nsPrefix] = $namespace;
 198              }
 199              $nsPrefix = $this->wsdl->getPrefixFromNamespace($namespace);
 200              // serialize payload
 201              if (is_string($params)) {
 202                  $this->debug("serializing param string for WSDL operation $operation");
 203                  $payload = $params;
 204              } elseif (is_array($params)) {
 205                  $this->debug("serializing param array for WSDL operation $operation");
 206                  $payload = $this->wsdl->serializeRPCParameters($operation,'input',$params);
 207              } else {
 208                  $this->debug('params must be array or string');
 209                  $this->setError('params must be array or string');
 210                  return false;
 211              }
 212              $usedNamespaces = $this->wsdl->usedNamespaces;
 213              if (isset($opData['input']['encodingStyle'])) {
 214                  $encodingStyle = $opData['input']['encodingStyle'];
 215              } else {
 216                  $encodingStyle = '';
 217              }
 218              $this->appendDebug($this->wsdl->getDebug());
 219              $this->wsdl->clearDebug();
 220              if ($errstr = $this->wsdl->getError()) {
 221                  $this->debug('got wsdl error: '.$errstr);
 222                  $this->setError('wsdl error: '.$errstr);
 223                  return false;
 224              }
 225          } elseif($this->endpointType == 'wsdl') {
 226              // operation not in WSDL
 227              $this->appendDebug($this->wsdl->getDebug());
 228              $this->wsdl->clearDebug();
 229              $this->setError( 'operation '.$operation.' not present.');
 230              $this->debug("operation '$operation' not present.");
 231              return false;
 232          } else {
 233              // no WSDL
 234              //$this->namespaces['ns1'] = $namespace;
 235              $nsPrefix = 'ns' . rand(1000, 9999);
 236              // serialize 
 237              $payload = '';
 238              if (is_string($params)) {
 239                  $this->debug("serializing param string for operation $operation");
 240                  $payload = $params;
 241              } elseif (is_array($params)) {
 242                  $this->debug("serializing param array for operation $operation");
 243                  foreach($params as $k => $v){
 244                      $payload .= $this->serialize_val($v,$k,false,false,false,false,$use);
 245                  }
 246              } else {
 247                  $this->debug('params must be array or string');
 248                  $this->setError('params must be array or string');
 249                  return false;
 250              }
 251              $usedNamespaces = array();
 252              if ($use == 'encoded') {
 253                  $encodingStyle = 'http://schemas.xmlsoap.org/soap/encoding/';
 254              } else {
 255                  $encodingStyle = '';
 256              }
 257          }
 258          // wrap RPC calls with method element
 259          if ($style == 'rpc') {
 260              if ($use == 'literal') {
 261                  $this->debug("wrapping RPC request with literal method element");
 262                  if ($namespace) {
 263                      $payload = "<$operation xmlns=\"$namespace\">" . $payload . "</$operation>";
 264                  } else {
 265                      $payload = "<$operation>" . $payload . "</$operation>";
 266                  }
 267              } else {
 268                  $this->debug("wrapping RPC request with encoded method element");
 269                  if ($namespace) {
 270                      $payload = "<$nsPrefix:$operation xmlns:$nsPrefix=\"$namespace\">" .
 271                                  $payload .
 272                                  "</$nsPrefix:$operation>";
 273                  } else {
 274                      $payload = "<$operation>" .
 275                                  $payload .
 276                                  "</$operation>";
 277                  }
 278              }
 279          }
 280          // serialize envelope
 281          $soapmsg = $this->serializeEnvelope($payload,$this->requestHeaders,$usedNamespaces,$style,$use,$encodingStyle);
 282          $this->debug("endpoint=$this->endpoint, soapAction=$soapAction, namespace=$namespace, style=$style, use=$use, encodingStyle=$encodingStyle");
 283          $this->debug('SOAP message length=' . strlen($soapmsg) . ' contents (max 1000 bytes)=' . substr($soapmsg, 0, 1000));
 284          // send
 285          $return = $this->send($this->getHTTPBody($soapmsg),$soapAction,$this->timeout,$this->response_timeout);
 286          if($errstr = $this->getError()){
 287              $this->debug('Error: '.$errstr);
 288              return false;
 289          } else {
 290              $this->return = $return;
 291              $this->debug('sent message successfully and got a(n) '.gettype($return));
 292                 $this->appendDebug('return=' . $this->varDump($return));
 293              
 294              // fault?
 295              if(is_array($return) && isset($return['faultcode'])){
 296                  $this->debug('got fault');
 297                  $this->setError($return['faultcode'].': '.$return['faultstring']);
 298                  $this->fault = true;
 299                  foreach($return as $k => $v){
 300                      $this->$k = $v;
 301                      $this->debug("$k = $v<br>");
 302                  }
 303                  return $return;
 304              } elseif ($style == 'document') {
 305                  // NOTE: if the response is defined to have multiple parts (i.e. unwrapped),
 306                  // we are only going to return the first part here...sorry about that
 307                  return $return;
 308              } else {
 309                  // array of return values
 310                  if(is_array($return)){
 311                      // multiple 'out' parameters, which we return wrapped up
 312                      // in the array
 313                      if(sizeof($return) > 1){
 314                          return $return;
 315                      }
 316                      // single 'out' parameter (normally the return value)
 317                      $return = array_shift($return);
 318                      $this->debug('return shifted value: ');
 319                      $this->appendDebug($this->varDump($return));
 320                         return $return;
 321                  // nothing returned (ie, echoVoid)
 322                  } else {
 323                      return "";
 324                  }
 325              }
 326          }
 327      }
 328  
 329      /**
 330      * get available data pertaining to an operation
 331      *
 332      * @param    string $operation operation name
 333      * @return    array array of data pertaining to the operation
 334      * @access   public
 335      */
 336  	function getOperationData($operation){
 337          if(isset($this->operations[$operation])){
 338              return $this->operations[$operation];
 339          }
 340          $this->debug("No data for operation: $operation");
 341      }
 342  
 343      /**
 344      * send the SOAP message
 345      *
 346      * Note: if the operation has multiple return values
 347      * the return value of this method will be an array
 348      * of those values.
 349      *
 350      * @param    string $msg a SOAPx4 soapmsg object
 351      * @param    string $soapaction SOAPAction value
 352      * @param    integer $timeout set connection timeout in seconds
 353      * @param    integer $response_timeout set response timeout in seconds
 354      * @return    mixed native PHP types.
 355      * @access   private
 356      */
 357  	function send($msg, $soapaction = '', $timeout=0, $response_timeout=30) {
 358          $this->checkCookies();
 359          // detect transport
 360          switch(true){
 361              // http(s)
 362              case ereg('^http',$this->endpoint):
 363                  $this->debug('transporting via HTTP');
 364                  if($this->persistentConnection == true && is_object($this->persistentConnection)){
 365                      $http =& $this->persistentConnection;
 366                  } else {
 367                      $http = new soap_transport_http($this->endpoint);
 368                      if ($this->persistentConnection) {
 369                          $http->usePersistentConnection();
 370                      }
 371                  }
 372                  $http->setContentType($this->getHTTPContentType(), $this->getHTTPContentTypeCharset());
 373                  $http->setSOAPAction($soapaction);
 374                  if($this->proxyhost && $this->proxyport){
 375                      $http->setProxy($this->proxyhost,$this->proxyport,$this->proxyusername,$this->proxypassword);
 376                  }
 377                  if($this->authtype != '') {
 378                      $http->setCredentials($this->username, $this->password, $this->authtype, array(), $this->certRequest);
 379                  }
 380                  if($this->http_encoding != ''){
 381                      $http->setEncoding($this->http_encoding);
 382                  }
 383                  $this->debug('sending message, length='.strlen($msg));
 384                  if(ereg('^http:',$this->endpoint)){
 385                  //if(strpos($this->endpoint,'http:')){
 386                      $this->responseData = $http->send($msg,$timeout,$response_timeout,$this->cookies);
 387                  } elseif(ereg('^https',$this->endpoint)){
 388                  //} elseif(strpos($this->endpoint,'https:')){
 389                      //if(phpversion() == '4.3.0-dev'){
 390                          //$response = $http->send($msg,$timeout,$response_timeout);
 391                             //$this->request = $http->outgoing_payload;
 392                          //$this->response = $http->incoming_payload;
 393                      //} else
 394                      $this->responseData = $http->sendHTTPS($msg,$timeout,$response_timeout,$this->cookies);
 395                  } else {
 396                      $this->setError('no http/s in endpoint url');
 397                  }
 398                  $this->request = $http->outgoing_payload;
 399                  $this->response = $http->incoming_payload;
 400                  $this->appendDebug($http->getDebug());
 401                  $this->UpdateCookies($http->incoming_cookies);
 402  
 403                  // save transport object if using persistent connections
 404                  if ($this->persistentConnection) {
 405                      $http->clearDebug();
 406                      if (!is_object($this->persistentConnection)) {
 407                          $this->persistentConnection = $http;
 408                      }
 409                  }
 410                  
 411                  if($err = $http->getError()){
 412                      $this->setError('HTTP Error: '.$err);
 413                      return false;
 414                  } elseif($this->getError()){
 415                      return false;
 416                  } else {
 417                      $this->debug('got response, length='. strlen($this->responseData).' type='.$http->incoming_headers['content-type']);
 418                      return $this->parseResponse($http->incoming_headers, $this->responseData);
 419                  }
 420              break;
 421              default:
 422                  $this->setError('no transport found, or selected transport is not yet supported!');
 423              return false;
 424              break;
 425          }
 426      }
 427  
 428      /**
 429      * processes SOAP message returned from server
 430      *
 431      * @param    array    $headers    The HTTP headers
 432      * @param    string    $data        unprocessed response data from server
 433      * @return    mixed    value of the message, decoded into a PHP type
 434      * @access   private
 435      */
 436      function parseResponse($headers, $data) {
 437          $this->debug('Entering parseResponse() for data of length ' . strlen($data) . ' and type ' . $headers['content-type']);
 438          if (!strstr($headers['content-type'], 'text/xml')) {
 439              $this->setError('Response not of type text/xml');
 440              return false;
 441          }
 442          if (strpos($headers['content-type'], '=')) {
 443              $enc = str_replace('"', '', substr(strstr($headers["content-type"], '='), 1));
 444              $this->debug('Got response encoding: ' . $enc);
 445              if(eregi('^(ISO-8859-1|US-ASCII|UTF-8)$',$enc)){
 446                  $this->xml_encoding = strtoupper($enc);
 447              } else {
 448                  $this->xml_encoding = 'US-ASCII';
 449              }
 450          } else {
 451              // should be US-ASCII for HTTP 1.0 or ISO-8859-1 for HTTP 1.1
 452              $this->xml_encoding = 'UTF-8';
 453          }
 454          $this->debug('Use encoding: ' . $this->xml_encoding . ' when creating soap_parser');
 455          $parser = new soap_parser($data,$this->xml_encoding,$this->operation,$this->decode_utf8);
 456          // add parser debug data to our debug
 457          $this->appendDebug($parser->getDebug());
 458          // if parse errors
 459          if($errstr = $parser->getError()){
 460              $this->setError( $errstr);
 461              // destroy the parser object
 462              unset($parser);
 463              return false;
 464          } else {
 465              // get SOAP headers
 466              $this->responseHeaders = $parser->getHeaders();
 467              // get decoded message
 468              $return = $parser->get_response();
 469              // add document for doclit support
 470              $this->document = $parser->document;
 471              // destroy the parser object
 472              unset($parser);
 473              // return decode message
 474              return $return;
 475          }
 476       }
 477  
 478      /**
 479      * sets the SOAP endpoint, which can override WSDL
 480      *
 481      * @param    $endpoint string The endpoint URL to use, or empty string or false to prevent override
 482      * @access   public
 483      */
 484  	function setEndpoint($endpoint) {
 485          $this->forceEndpoint = $endpoint;
 486      }
 487  
 488      /**
 489      * set the SOAP headers
 490      *
 491      * @param    $headers mixed String of XML with SOAP header content, or array of soapval objects for SOAP headers
 492      * @access   public
 493      */
 494  	function setHeaders($headers){
 495          $this->requestHeaders = $headers;
 496      }
 497  
 498      /**
 499      * get the SOAP response headers (namespace resolution incomplete)
 500      *
 501      * @return    string
 502      * @access   public
 503      */
 504  	function getHeaders(){
 505          return $this->responseHeaders;
 506      }
 507  
 508      /**
 509      * set proxy info here
 510      *
 511      * @param    string $proxyhost
 512      * @param    string $proxyport
 513      * @param    string $proxyusername
 514      * @param    string $proxypassword
 515      * @access   public
 516      */
 517  	function setHTTPProxy($proxyhost, $proxyport, $proxyusername = '', $proxypassword = '') {
 518          $this->proxyhost = $proxyhost;
 519          $this->proxyport = $proxyport;
 520          $this->proxyusername = $proxyusername;
 521          $this->proxypassword = $proxypassword;
 522      }
 523  
 524      /**
 525      * if authenticating, set user credentials here
 526      *
 527      * @param    string $username
 528      * @param    string $password
 529      * @param    string $authtype (basic|digest|certificate)
 530      * @param    array $certRequest (keys must be cainfofile (optional), sslcertfile, sslkeyfile, passphrase, verifypeer (optional), verifyhost (optional): see corresponding options in cURL docs)
 531      * @access   public
 532      */
 533  	function setCredentials($username, $password, $authtype = 'basic', $certRequest = array()) {
 534          $this->username = $username;
 535          $this->password = $password;
 536          $this->authtype = $authtype;
 537          $this->certRequest = $certRequest;
 538      }
 539      
 540      /**
 541      * use HTTP encoding
 542      *
 543      * @param    string $enc
 544      * @access   public
 545      */
 546  	function setHTTPEncoding($enc='gzip, deflate'){
 547          $this->http_encoding = $enc;
 548      }
 549      
 550      /**
 551      * use HTTP persistent connections if possible
 552      *
 553      * @access   public
 554      */
 555  	function useHTTPPersistentConnection(){
 556          $this->persistentConnection = true;
 557      }
 558      
 559      /**
 560      * gets the default RPC parameter setting.
 561      * If true, default is that call params are like RPC even for document style.
 562      * Each call() can override this value.
 563      *
 564      * This is no longer used.
 565      *
 566      * @return boolean
 567      * @access public
 568      * @deprecated
 569      */
 570  	function getDefaultRpcParams() {
 571          return $this->defaultRpcParams;
 572      }
 573  
 574      /**
 575      * sets the default RPC parameter setting.
 576      * If true, default is that call params are like RPC even for document style
 577      * Each call() can override this value.
 578      *
 579      * This is no longer used.
 580      *
 581      * @param    boolean $rpcParams
 582      * @access public
 583      * @deprecated
 584      */
 585  	function setDefaultRpcParams($rpcParams) {
 586          $this->defaultRpcParams = $rpcParams;
 587      }
 588      
 589      /**
 590      * dynamically creates an instance of a proxy class,
 591      * allowing user to directly call methods from wsdl
 592      *
 593      * @return   object soap_proxy object
 594      * @access   public
 595      */
 596  	function getProxy(){
 597          $r = rand();
 598          $evalStr = $this->_getProxyClassCode($r);
 599          //$this->debug("proxy class: $evalStr";
 600          // eval the class
 601          eval($evalStr);
 602          // instantiate proxy object
 603          eval("\$proxy = new soap_proxy_$r('');");
 604          // transfer current wsdl data to the proxy thereby avoiding parsing the wsdl twice
 605          $proxy->endpointType = 'wsdl';
 606          $proxy->wsdlFile = $this->wsdlFile;
 607          $proxy->wsdl = $this->wsdl;
 608          $proxy->operations = $this->operations;
 609          $proxy->defaultRpcParams = $this->defaultRpcParams;
 610          // transfer other state
 611          $proxy->username = $this->username;
 612          $proxy->password = $this->password;
 613          $proxy->authtype = $this->authtype;
 614          $proxy->proxyhost = $this->proxyhost;
 615          $proxy->proxyport = $this->proxyport;
 616          $proxy->proxyusername = $this->proxyusername;
 617          $proxy->proxypassword = $this->proxypassword;
 618          $proxy->timeout = $this->timeout;
 619          $proxy->response_timeout = $this->response_timeout;
 620          $proxy->http_encoding = $this->http_encoding;
 621          $proxy->persistentConnection = $this->persistentConnection;
 622          $proxy->requestHeaders = $this->requestHeaders;
 623          $proxy->soap_defencoding = $this->soap_defencoding;
 624          $proxy->endpoint = $this->endpoint;
 625          $proxy->forceEndpoint = $this->forceEndpoint;
 626          return $proxy;
 627      }
 628  
 629      /**
 630      * dynamically creates proxy class code
 631      *
 632      * @return   string PHP/NuSOAP code for the proxy class
 633      * @access   private
 634      */
 635  	function _getProxyClassCode($r) {
 636          if ($this->endpointType != 'wsdl') {
 637              $evalStr = 'A proxy can only be created for a WSDL client';
 638              $this->setError($evalStr);
 639              return $evalStr;
 640          }
 641          $evalStr = '';
 642          foreach ($this->operations as $operation => $opData) {
 643              if ($operation != '') {
 644                  // create param string and param comment string
 645                  if (sizeof($opData['input']['parts']) > 0) {
 646                      $paramStr = '';
 647                      $paramArrayStr = '';
 648                      $paramCommentStr = '';
 649                      foreach ($opData['input']['parts'] as $name => $type) {
 650                          $paramStr .= "\$$name, ";
 651                          $paramArrayStr .= "'$name' => \$$name, ";
 652                          $paramCommentStr .= "$type \$$name, ";
 653                      }
 654                      $paramStr = substr($paramStr, 0, strlen($paramStr)-2);
 655                      $paramArrayStr = substr($paramArrayStr, 0, strlen($paramArrayStr)-2);
 656                      $paramCommentStr = substr($paramCommentStr, 0, strlen($paramCommentStr)-2);
 657                  } else {
 658                      $paramStr = '';
 659                      $paramCommentStr = 'void';
 660                  }
 661                  $opData['namespace'] = !isset($opData['namespace']) ? 'http://testuri.com' : $opData['namespace'];
 662                  $evalStr .= "// $paramCommentStr
 663      function " . str_replace('.', '__', $operation) . "($paramStr) {
 664          \$params = array($paramArrayStr);
 665          return \$this->call('$operation', \$params, '".$opData['namespace']."', '".(isset($opData['soapAction']) ? $opData['soapAction'] : '')."');
 666      }
 667      ";
 668                  unset($paramStr);
 669                  unset($paramCommentStr);
 670              }
 671          }
 672          $evalStr = 'class soap_proxy_'.$r.' extends soapclient2 {
 673      '.$evalStr.'
 674  }';
 675          return $evalStr;
 676      }
 677  
 678      /**
 679      * dynamically creates proxy class code
 680      *
 681      * @return   string PHP/NuSOAP code for the proxy class
 682      * @access   public
 683      */
 684  	function getProxyClassCode() {
 685          $r = rand();
 686          return $this->_getProxyClassCode($r);
 687      }
 688  
 689      /**
 690      * gets the HTTP body for the current request.
 691      *
 692      * @param string $soapmsg The SOAP payload
 693      * @return string The HTTP body, which includes the SOAP payload
 694      * @access private
 695      */
 696  	function getHTTPBody($soapmsg) {
 697          return $soapmsg;
 698      }
 699      
 700      /**
 701      * gets the HTTP content type for the current request.
 702      *
 703      * Note: getHTTPBody must be called before this.
 704      *
 705      * @return string the HTTP content type for the current request.
 706      * @access private
 707      */
 708  	function getHTTPContentType() {
 709          return 'text/xml';
 710      }
 711      
 712      /**
 713      * gets the HTTP content type charset for the current request.
 714      * returns false for non-text content types.
 715      *
 716      * Note: getHTTPBody must be called before this.
 717      *
 718      * @return string the HTTP content type charset for the current request.
 719      * @access private
 720      */
 721  	function getHTTPContentTypeCharset() {
 722          return $this->soap_defencoding;
 723      }
 724  
 725      /*
 726      * whether or not parser should decode utf8 element content
 727      *
 728      * @return   always returns true
 729      * @access   public
 730      */
 731      function decodeUTF8($bool){
 732          $this->decode_utf8 = $bool;
 733          return true;
 734      }
 735  
 736      /**
 737       * adds a new Cookie into $this->cookies array
 738       *
 739       * @param    string $name Cookie Name
 740       * @param    string $value Cookie Value
 741       * @return    if cookie-set was successful returns true, else false
 742       * @access    public
 743       */
 744  	function setCookie($name, $value) {
 745          if (strlen($name) == 0) {
 746              return false;
 747          }
 748          $this->cookies[] = array('name' => $name, 'value' => $value);
 749          return true;
 750      }
 751  
 752      /**
 753       * gets all Cookies
 754       *
 755       * @return   array with all internal cookies
 756       * @access   public
 757       */
 758  	function getCookies() {
 759          return $this->cookies;
 760      }
 761  
 762      /**
 763       * checks all Cookies and delete those which are expired
 764       *
 765       * @return   always return true
 766       * @access   private
 767       */
 768  	function checkCookies() {
 769          if (sizeof($this->cookies) == 0) {
 770              return true;
 771          }
 772          $this->debug('checkCookie: check ' . sizeof($this->cookies) . ' cookies');
 773          $curr_cookies = $this->cookies;
 774          $this->cookies = array();
 775          foreach ($curr_cookies as $cookie) {
 776              if (! is_array($cookie)) {
 777                  $this->debug('Remove cookie that is not an array');
 778                  continue;
 779              }
 780              if ((isset($cookie['expires'])) && (! empty($cookie['expires']))) {
 781                  if (strtotime($cookie['expires']) > time()) {
 782                      $this->cookies[] = $cookie;
 783                  } else {
 784                      $this->debug('Remove expired cookie ' . $cookie['name']);
 785                  }
 786              } else {
 787                  $this->cookies[] = $cookie;
 788              }
 789          }
 790          $this->debug('checkCookie: '.sizeof($this->cookies).' cookies left in array');
 791          return true;
 792      }
 793  
 794      /**
 795       * updates the current cookies with a new set
 796       *
 797       * @param    array $cookies new cookies with which to update current ones
 798       * @return    always return true
 799       * @access    private
 800       */
 801  	function UpdateCookies($cookies) {
 802          if (sizeof($this->cookies) == 0) {
 803              // no existing cookies: take whatever is new
 804              if (sizeof($cookies) > 0) {
 805                  $this->debug('Setting new cookie(s)');
 806                  $this->cookies = $cookies;
 807              }
 808              return true;
 809          }
 810          if (sizeof($cookies) == 0) {
 811              // no new cookies: keep what we've got
 812              return true;
 813          }
 814          // merge
 815          foreach ($cookies as $newCookie) {
 816              if (!is_array($newCookie)) {
 817                  continue;
 818              }
 819              if ((!isset($newCookie['name'])) || (!isset($newCookie['value']))) {
 820                  continue;
 821              }
 822              $newName = $newCookie['name'];
 823  
 824              $found = false;
 825              for ($i = 0; $i < count($this->cookies); $i++) {
 826                  $cookie = $this->cookies[$i];
 827                  if (!is_array($cookie)) {
 828                      continue;
 829                  }
 830                  if (!isset($cookie['name'])) {
 831                      continue;
 832                  }
 833                  if ($newName != $cookie['name']) {
 834                      continue;
 835                  }
 836                  $newDomain = isset($newCookie['domain']) ? $newCookie['domain'] : 'NODOMAIN';
 837                  $domain = isset($cookie['domain']) ? $cookie['domain'] : 'NODOMAIN';
 838                  if ($newDomain != $domain) {
 839                      continue;
 840                  }
 841                  $newPath = isset($newCookie['path']) ? $newCookie['path'] : 'NOPATH';
 842                  $path = isset($cookie['path']) ? $cookie['path'] : 'NOPATH';
 843                  if ($newPath != $path) {
 844                      continue;
 845                  }
 846                  $this->cookies[$i] = $newCookie;
 847                  $found = true;
 848                  $this->debug('Update cookie ' . $newName . '=' . $newCookie['value']);
 849                  break;
 850              }
 851              if (! $found) {
 852                  $this->debug('Add cookie ' . $newName . '=' . $newCookie['value']);
 853                  $this->cookies[] = $newCookie;
 854              }
 855          }
 856          return true;
 857      }
 858  }
 859  ?>