source: pmb4.2/trunk/fuentes/pmb/classes/nusoap/class.nusoapclient.php @ 815

Last change on this file since 815 was 815, checked in by jrpelegrina, 4 years ago

Initial release of pmb 4.2

  • Property svn:executable set to *
File size: 27.8 KB
Line 
1<?php
2
3
4
5
6/**
7*
8* soapclient higher level class for easy usage.
9*
10* usage:
11*
12* // instantiate client with server info
13* $soapclient = new soapclient( string path [ ,boolean wsdl] );
14*
15* // call method, get results
16* echo $soapclient->call( string methodname [ ,array parameters] );
17*
18* // bye bye client
19* unset($soapclient);
20*
21* @author   Dietrich Ayala <dietrich@ganx4.com>
22* @version  $Id: class.nusoapclient.php,v 1.3 2013-04-11 08:14:12 mbertin Exp $
23* @access   public
24*/
25class soapclient 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 soapclient($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 = 'ISO-8859-1';
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 soapclient {
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?>
Note: See TracBrowser for help on using the repository browser.