1 | <?php |
---|
2 | /** |
---|
3 | * This file contains the code for the SOAP server. |
---|
4 | * |
---|
5 | * PHP versions 4 and 5 |
---|
6 | * |
---|
7 | * LICENSE: This source file is subject to version 2.02 of the PHP license, |
---|
8 | * that is bundled with this package in the file LICENSE, and is available at |
---|
9 | * through the world-wide-web at http://www.php.net/license/2_02.txt. If you |
---|
10 | * did not receive a copy of the PHP license and are unable to obtain it |
---|
11 | * through the world-wide-web, please send a note to license@php.net so we can |
---|
12 | * mail you a copy immediately. |
---|
13 | * |
---|
14 | * @category Web Services |
---|
15 | * @package SOAP |
---|
16 | * @author Dietrich Ayala <dietrich@ganx4.com> Original Author |
---|
17 | * @author Shane Caraveo <Shane@Caraveo.com> Port to PEAR and more |
---|
18 | * @author Chuck Hagenbuch <chuck@horde.org> Maintenance |
---|
19 | * @author Jan Schneider <jan@horde.org> Maintenance |
---|
20 | * @copyright 2003-2005 The PHP Group |
---|
21 | * @license http://www.php.net/license/2_02.txt PHP License 2.02 |
---|
22 | * @link http://pear.php.net/package/SOAP |
---|
23 | */ |
---|
24 | |
---|
25 | require_once 'SOAP/Base.php'; |
---|
26 | require_once 'SOAP/Fault.php'; |
---|
27 | require_once 'SOAP/Parser.php'; |
---|
28 | require_once 'SOAP/Value.php'; |
---|
29 | require_once 'SOAP/WSDL.php'; |
---|
30 | |
---|
31 | /** |
---|
32 | * SOAP Server Class |
---|
33 | * |
---|
34 | * Originaly based on SOAPx4 by Dietrich Ayala |
---|
35 | * http://dietrich.ganx4.com/soapx4 |
---|
36 | * |
---|
37 | * @access public |
---|
38 | * @package SOAP |
---|
39 | * @author Shane Caraveo <shane@php.net> Conversion to PEAR and updates |
---|
40 | * @author Dietrich Ayala <dietrich@ganx4.com> Original Author |
---|
41 | */ |
---|
42 | class SOAP_Server extends SOAP_Base |
---|
43 | { |
---|
44 | /** |
---|
45 | * |
---|
46 | * @var array |
---|
47 | */ |
---|
48 | var $dispatch_map = array(); // create empty dispatch map |
---|
49 | var $dispatch_objects = array(); |
---|
50 | var $soapobject = null; |
---|
51 | var $call_methodname = null; |
---|
52 | var $callHandler = null; |
---|
53 | var $callValidation = true; |
---|
54 | |
---|
55 | /** |
---|
56 | * A list of headers that are going to be sent back to the client. |
---|
57 | * |
---|
58 | * @var array |
---|
59 | */ |
---|
60 | var $headers = array(); |
---|
61 | |
---|
62 | /** |
---|
63 | * |
---|
64 | * @var string |
---|
65 | */ |
---|
66 | var $request = ''; |
---|
67 | |
---|
68 | /** |
---|
69 | * |
---|
70 | * @var string XML-Encoding |
---|
71 | */ |
---|
72 | var $xml_encoding = SOAP_DEFAULT_ENCODING; |
---|
73 | var $response_encoding = 'UTF-8'; |
---|
74 | |
---|
75 | var $result = 'successful'; // for logging interop results to db |
---|
76 | |
---|
77 | var $endpoint = ''; // the uri to ME! |
---|
78 | |
---|
79 | var $service = ''; //soapaction header |
---|
80 | var $method_namespace = null; |
---|
81 | |
---|
82 | /** |
---|
83 | * Options. |
---|
84 | * |
---|
85 | * @var array |
---|
86 | */ |
---|
87 | var $_options = array('use' => 'encoded', |
---|
88 | 'style' => 'rpc', |
---|
89 | 'parameters' => 0, |
---|
90 | 'http_status_success' => '200 OK', |
---|
91 | 'http_status_fault' => '500 SOAP Fault'); |
---|
92 | |
---|
93 | function SOAP_Server($options = null) |
---|
94 | { |
---|
95 | ini_set('track_errors', 1); |
---|
96 | parent::SOAP_Base('Server'); |
---|
97 | |
---|
98 | if (is_array($options)) { |
---|
99 | if (isset($options['use'])) { |
---|
100 | $this->_options['use'] = $options['use']; |
---|
101 | } |
---|
102 | if (isset($options['style'])) { |
---|
103 | $this->_options['style'] = $options['style']; |
---|
104 | } |
---|
105 | if (isset($options['parameters'])) { |
---|
106 | $this->_options['parameters'] = $options['parameters']; |
---|
107 | } |
---|
108 | } |
---|
109 | // assume we encode with section 5 |
---|
110 | $this->_section5 = true; |
---|
111 | if ($this->_options['use'] == 'literal') { |
---|
112 | $this->_section5 = false; |
---|
113 | } |
---|
114 | } |
---|
115 | |
---|
116 | /** |
---|
117 | * Error handler for errors that happen in proxied methods. |
---|
118 | * |
---|
119 | * To always return a valid SOAP response even on errors that don't happen |
---|
120 | * in this code, the errors are catched, transformed to a SOAP fault and |
---|
121 | * immediately sent to the client. |
---|
122 | * |
---|
123 | * @see http://www.php.net/set_error_handler |
---|
124 | */ |
---|
125 | function _errorHandler($errno, $errmsg, $filename, $linenum) |
---|
126 | { |
---|
127 | /* The error handler should ignore '0' errors, eg. hidden by @ - see |
---|
128 | * the set_error_handler manual page. (thanks to Alan Knowles). */ |
---|
129 | if (!$errno || !error_reporting() || $errno == E_NOTICE || |
---|
130 | (defined('E_STRICT') && $errno == constant('E_STRICT'))) { |
---|
131 | return false; |
---|
132 | } |
---|
133 | |
---|
134 | $this->fault = new SOAP_Fault($errmsg, 'Server', 'PHP', "Errno: $errno\nFilename: $filename\nLineno: $linenum\n"); |
---|
135 | |
---|
136 | $this->_sendResponse(); |
---|
137 | exit; |
---|
138 | } |
---|
139 | |
---|
140 | function _getContentEncoding($content_type) |
---|
141 | { |
---|
142 | /* Get the character encoding of the incoming request treat incoming |
---|
143 | * data as UTF-8 if no encoding set. */ |
---|
144 | $this->xml_encoding = 'UTF-8'; |
---|
145 | if (strpos($content_type, '=')) { |
---|
146 | $enc = strtoupper(str_replace('"', '', substr(strstr($content_type, '='), 1))); |
---|
147 | if (!in_array($enc, $this->_encodings)) { |
---|
148 | return false; |
---|
149 | } |
---|
150 | $this->xml_encoding = $enc; |
---|
151 | } |
---|
152 | |
---|
153 | return true; |
---|
154 | } |
---|
155 | |
---|
156 | |
---|
157 | /** |
---|
158 | * Parses the request and posts or returns the response. |
---|
159 | * |
---|
160 | * @param string $data The SOAP request data. |
---|
161 | * @param string $endpoint The service endpoint. Determined automatically |
---|
162 | * if left empty. |
---|
163 | * @param boolean $test |
---|
164 | * @param boolean $return Whether to return the SOAP response data |
---|
165 | * instead of sending it to the client. |
---|
166 | */ |
---|
167 | function service($data, $endpoint = '', $test = false, $return = false) |
---|
168 | { |
---|
169 | $response = null; |
---|
170 | $attachments = array(); |
---|
171 | $useEncoding = 'DIME'; |
---|
172 | |
---|
173 | /* Figure out our endpoint. */ |
---|
174 | $this->endpoint = $endpoint; |
---|
175 | if (!$test && !$this->endpoint) { |
---|
176 | /* We'll try to build our endpoint. */ |
---|
177 | $this->endpoint = 'http://' . $_SERVER['SERVER_NAME']; |
---|
178 | if ($_SERVER['SERVER_PORT']) { |
---|
179 | $this->endpoint .= ':' . $_SERVER['SERVER_PORT']; |
---|
180 | } |
---|
181 | $this->endpoint .= $_SERVER['SCRIPT_NAME']; |
---|
182 | } |
---|
183 | |
---|
184 | /* Get the character encoding of the incoming request treat incoming |
---|
185 | * data as UTF-8 if no encoding set. */ |
---|
186 | if (isset($_SERVER['CONTENT_TYPE'])) { |
---|
187 | if (strcasecmp($_SERVER['CONTENT_TYPE'], 'application/dime') == 0) { |
---|
188 | $this->_decodeDIMEMessage($data, $headers, $attachments); |
---|
189 | $useEncoding = 'DIME'; |
---|
190 | } elseif (stristr($_SERVER['CONTENT_TYPE'], 'multipart/related')) { |
---|
191 | /* This is a mime message, let's decode it. */ |
---|
192 | $data = 'Content-Type: ' . |
---|
193 | stripslashes($_SERVER['CONTENT_TYPE']) . |
---|
194 | "\r\n\r\n" . $data; |
---|
195 | $this->_decodeMimeMessage($data, $headers, $attachments); |
---|
196 | $useEncoding = 'Mime'; |
---|
197 | } |
---|
198 | if (!isset($headers['content-type'])) { |
---|
199 | $headers['content-type'] = stripslashes($_SERVER['CONTENT_TYPE']); |
---|
200 | } |
---|
201 | if (!$this->fault && |
---|
202 | !$this->_getContentEncoding($headers['content-type'])) { |
---|
203 | $this->xml_encoding = SOAP_DEFAULT_ENCODING; |
---|
204 | /* Found encoding we don't understand; return a fault. */ |
---|
205 | $this->_raiseSoapFault('Unsupported encoding, use one of ISO-8859-1, US-ASCII, UTF-8', '', '', 'Server'); |
---|
206 | } |
---|
207 | } |
---|
208 | |
---|
209 | /* If this is not a POST with Content-Type text/xml, try to return a |
---|
210 | * WSDL file. */ |
---|
211 | if (!$this->fault && !$test && |
---|
212 | ($_SERVER['REQUEST_METHOD'] != 'POST' || |
---|
213 | strncmp($headers['content-type'], 'text/xml', 8) != 0)) { |
---|
214 | /* This is not possibly a valid SOAP request, try to return a WSDL |
---|
215 | * file. */ |
---|
216 | $this->_raiseSoapFault('Invalid SOAP request, must be POST with content-type: text/xml, got: ' . (isset($headers['content-type']) ? $headers['content-type'] : 'Nothing!'), '', '', 'Server'); |
---|
217 | } |
---|
218 | |
---|
219 | if (!$this->fault) { |
---|
220 | /* $response is a SOAP_Msg object. */ |
---|
221 | $soap_msg = $this->parseRequest($data, $attachments); |
---|
222 | |
---|
223 | /* Handle Mime or DIME encoding. */ |
---|
224 | /* TODO: DIME decoding should move to the transport, do it here |
---|
225 | * for now and for ease of getting it done. */ |
---|
226 | if (count($this->_attachments)) { |
---|
227 | if ($useEncoding == 'Mime') { |
---|
228 | $soap_msg = $this->_makeMimeMessage($soap_msg); |
---|
229 | } else { |
---|
230 | // default is dime |
---|
231 | $soap_msg = $this->_makeDIMEMessage($soap_msg); |
---|
232 | $this->headers['Content-Type'] = 'application/dime'; |
---|
233 | } |
---|
234 | if (PEAR::isError($soap_msg)) { |
---|
235 | return $this->_raiseSoapFault($soap_msg); |
---|
236 | } |
---|
237 | } |
---|
238 | |
---|
239 | if (is_array($soap_msg)) { |
---|
240 | $response = $soap_msg['body']; |
---|
241 | if (count($soap_msg['headers'])) { |
---|
242 | $this->headers = $soap_msg['headers']; |
---|
243 | } |
---|
244 | } else { |
---|
245 | $response = $soap_msg; |
---|
246 | } |
---|
247 | } |
---|
248 | |
---|
249 | if ($return) { |
---|
250 | if ($this->fault) { |
---|
251 | $response = $this->fault->message(); |
---|
252 | } |
---|
253 | return $response; |
---|
254 | } |
---|
255 | |
---|
256 | $this->_sendResponse($response); |
---|
257 | } |
---|
258 | |
---|
259 | /** |
---|
260 | * Sends the final HTTP response to the client, including the HTTP header |
---|
261 | * and the HTTP body. |
---|
262 | * |
---|
263 | * If an error happened, it returns a SOAP fault instead of the response |
---|
264 | * body. |
---|
265 | * |
---|
266 | * @param string $response The response body. |
---|
267 | */ |
---|
268 | function _sendResponse($response = '') |
---|
269 | { |
---|
270 | /* Make distinction between the different SAPIs, running PHP as CGI or |
---|
271 | * as a module. */ |
---|
272 | if (stristr(php_sapi_name(), 'cgi') === 0) { |
---|
273 | $hdrs_type = 'Status:'; |
---|
274 | } else { |
---|
275 | $hdrs_type = 'HTTP/1.1'; |
---|
276 | } |
---|
277 | |
---|
278 | if ($this->fault) { |
---|
279 | $hdrs = $hdrs_type . ' ' . $this->_options['http_status_fault'] . "\r\n"; |
---|
280 | $response = $this->fault->message($this->response_encoding); |
---|
281 | } else { |
---|
282 | $hdrs = $hdrs_type . ' ' . $this->_options['http_status_success'] . "\r\n"; |
---|
283 | } |
---|
284 | header($hdrs); |
---|
285 | |
---|
286 | $this->headers['Server'] = SOAP_LIBRARY_NAME; |
---|
287 | if (!isset($this->headers['Content-Type'])) { |
---|
288 | $this->headers['Content-Type'] = 'text/xml; charset=' . |
---|
289 | $this->response_encoding; |
---|
290 | } |
---|
291 | $this->headers['Content-Length'] = strlen($response); |
---|
292 | |
---|
293 | foreach ($this->headers as $k => $v) { |
---|
294 | header("$k: $v"); |
---|
295 | $hdrs .= "$k: $v\r\n"; |
---|
296 | } |
---|
297 | |
---|
298 | $this->response = $hdrs . "\r\n" . $response; |
---|
299 | print $response; |
---|
300 | } |
---|
301 | |
---|
302 | function &callMethod($methodname, &$args) |
---|
303 | { |
---|
304 | if ($this->callHandler) { |
---|
305 | $ret = @call_user_func_array($this->callHandler, array($methodname, $args)); |
---|
306 | return $ret; |
---|
307 | } |
---|
308 | |
---|
309 | set_error_handler(array($this, '_errorHandler')); |
---|
310 | |
---|
311 | if ($args) { |
---|
312 | /* Call method with parameters. */ |
---|
313 | if (isset($this->soapobject) && is_object($this->soapobject)) { |
---|
314 | $ret = call_user_func_array(array(&$this->soapobject, $methodname), $args); |
---|
315 | } else { |
---|
316 | $ret = call_user_func_array($methodname, $args); |
---|
317 | } |
---|
318 | } else { |
---|
319 | /* Call method withour parameters. */ |
---|
320 | if (is_object($this->soapobject)) { |
---|
321 | $ret = call_user_func(array(&$this->soapobject, $methodname)); |
---|
322 | } else { |
---|
323 | $ret = call_user_func($methodname); |
---|
324 | } |
---|
325 | } |
---|
326 | |
---|
327 | restore_error_handler(); |
---|
328 | |
---|
329 | return $ret; |
---|
330 | } |
---|
331 | |
---|
332 | /** |
---|
333 | * Creates SOAP_Value objects with return values from method. |
---|
334 | * Uses method signature to determine type. |
---|
335 | * |
---|
336 | * @param mixed $method_response The result(s). |
---|
337 | * @param array|string $type The type(s) of the return value(s). |
---|
338 | * @param string $return_name The name of the return value. |
---|
339 | * @param string $namespace The namespace of the return value. |
---|
340 | * |
---|
341 | * @return array List of SOAP_Value objects. |
---|
342 | */ |
---|
343 | function buildResult(&$method_response, &$return_type, |
---|
344 | $return_name = 'return', $namespace = '') |
---|
345 | { |
---|
346 | if (is_a($method_response, 'SOAP_Value')) { |
---|
347 | $return_val = array($method_response); |
---|
348 | } else { |
---|
349 | if (is_array($return_type) && is_array($method_response)) { |
---|
350 | $i = 0; |
---|
351 | |
---|
352 | foreach ($return_type as $key => $type) { |
---|
353 | if (is_numeric($key)) { |
---|
354 | $key = 'item'; |
---|
355 | } |
---|
356 | if (is_a($method_response[$i], 'SOAP_Value')) { |
---|
357 | $return_val[] =& $method_response[$i++]; |
---|
358 | } else { |
---|
359 | $qn = new QName($key, $namespace); |
---|
360 | $return_val[] = new SOAP_Value($qn->fqn(), $type, $method_response[$i++]); |
---|
361 | } |
---|
362 | } |
---|
363 | } else { |
---|
364 | if (is_array($return_type)) { |
---|
365 | $keys = array_keys($return_type); |
---|
366 | if (!is_numeric($keys[0])) { |
---|
367 | $return_name = $keys[0]; |
---|
368 | } |
---|
369 | $values = array_values($return_type); |
---|
370 | $return_type = $values[0]; |
---|
371 | } |
---|
372 | $qn = new QName($return_name, $namespace); |
---|
373 | $return_val = array(new SOAP_Value($qn->fqn(), $return_type, $method_response)); |
---|
374 | } |
---|
375 | } |
---|
376 | return $return_val; |
---|
377 | } |
---|
378 | |
---|
379 | function parseRequest($data = '', $attachments = null) |
---|
380 | { |
---|
381 | /* Parse response, get SOAP_Parser object. */ |
---|
382 | $parser =& new SOAP_Parser($data, $this->xml_encoding, $attachments); |
---|
383 | /* If fault occurred during message parsing. */ |
---|
384 | if ($parser->fault) { |
---|
385 | $this->fault = $parser->fault; |
---|
386 | return null; |
---|
387 | } |
---|
388 | |
---|
389 | /* Handle message headers. */ |
---|
390 | $request_headers = $parser->getHeaders(); |
---|
391 | $header_results = array(); |
---|
392 | |
---|
393 | if ($request_headers) { |
---|
394 | if (!is_a($request_headers, 'SOAP_Value')) { |
---|
395 | $this->_raiseSoapFault('Parser did not return SOAP_Value object: ' . $request_headers, '', '', 'Server'); |
---|
396 | return null; |
---|
397 | } |
---|
398 | if ($request_headers->value) { |
---|
399 | /* Handle headers now. */ |
---|
400 | foreach ($request_headers->value as $header_val) { |
---|
401 | $f_exists = $this->validateMethod($header_val->name, $header_val->namespace); |
---|
402 | |
---|
403 | /* TODO: this does not take into account message routing |
---|
404 | * yet. */ |
---|
405 | $myactor = !$header_val->actor || |
---|
406 | $header_val->actor == 'http://schemas.xmlsoap.org/soap/actor/next' || |
---|
407 | $header_val->actor == $this->endpoint; |
---|
408 | |
---|
409 | if (!$f_exists && $header_val->mustunderstand && $myactor) { |
---|
410 | $this->_raiseSoapFault('I don\'t understand header ' . $header_val->name, '', '', 'MustUnderstand'); |
---|
411 | return null; |
---|
412 | } |
---|
413 | |
---|
414 | /* We only handle the header if it's for us. */ |
---|
415 | $isok = $f_exists && $myactor; |
---|
416 | |
---|
417 | if ($isok) { |
---|
418 | /* Call our header now! */ |
---|
419 | $header_method = $header_val->name; |
---|
420 | $header_data = array($this->_decode($header_val)); |
---|
421 | /* If there are parameters to pass. */ |
---|
422 | $hr =& $this->callMethod($header_method, $header_data); |
---|
423 | if (PEAR::isError($hr)) { |
---|
424 | $this->_raiseSoapFault($hr); |
---|
425 | return null; |
---|
426 | } |
---|
427 | $results = $this->buildResult($hr, $this->return_type, $header_method, $header_val->namespace); |
---|
428 | $header_results[] = $results[0]; |
---|
429 | } |
---|
430 | } |
---|
431 | } |
---|
432 | } |
---|
433 | |
---|
434 | /* Handle the method call. */ |
---|
435 | /* Evaluate message, getting back a SOAP_Value object. */ |
---|
436 | $this->call_methodname = $this->methodname = $parser->root_struct_name[0]; |
---|
437 | |
---|
438 | /* Figure out the method namespace. */ |
---|
439 | $this->method_namespace = $parser->message[$parser->root_struct[0]]['namespace']; |
---|
440 | |
---|
441 | if ($this->_wsdl) { |
---|
442 | $this->_setSchemaVersion($this->_wsdl->xsd); |
---|
443 | $dataHandler = $this->_wsdl->getDataHandler($this->methodname, $this->method_namespace); |
---|
444 | if ($dataHandler) |
---|
445 | $this->call_methodname = $this->methodname = $dataHandler; |
---|
446 | |
---|
447 | $this->_portName = $this->_wsdl->getPortName($this->methodname); |
---|
448 | if (PEAR::isError($this->_portName)) { |
---|
449 | $this->_raiseSoapFault($this->_portName); |
---|
450 | return null; |
---|
451 | } |
---|
452 | $opData = $this->_wsdl->getOperationData($this->_portName, $this->methodname); |
---|
453 | if (PEAR::isError($opData)) { |
---|
454 | $this->_raiseSoapFault($opData); |
---|
455 | return null; |
---|
456 | } |
---|
457 | $this->_options['style'] = $opData['style']; |
---|
458 | $this->_options['use'] = $opData['output']['use']; |
---|
459 | $this->_options['parameters'] = $opData['parameters']; |
---|
460 | } |
---|
461 | |
---|
462 | /* Does method exist? */ |
---|
463 | if (!$this->methodname || |
---|
464 | !$this->validateMethod($this->methodname, $this->method_namespace)) { |
---|
465 | $this->_raiseSoapFault('method "' . $this->method_namespace . $this->methodname . '" not defined in service', '', '', 'Server'); |
---|
466 | return null; |
---|
467 | } |
---|
468 | |
---|
469 | if (!$request_val = $parser->getResponse()) { |
---|
470 | return null; |
---|
471 | } |
---|
472 | if (!is_a($request_val, 'SOAP_Value')) { |
---|
473 | $this->_raiseSoapFault('Parser did not return SOAP_Value object: ' . $request_val, '', '', 'Server'); |
---|
474 | return null; |
---|
475 | } |
---|
476 | |
---|
477 | /* Verify that SOAP_Value objects in request match the methods |
---|
478 | * signature. */ |
---|
479 | if (!$this->verifyMethod($request_val)) { |
---|
480 | /* verifyMethod() creates the fault. */ |
---|
481 | return null; |
---|
482 | } |
---|
483 | |
---|
484 | /* Need to set special error detection inside the value class to |
---|
485 | * differentiate between no params passed, and an error decoding. */ |
---|
486 | $request_data = $this->__decodeRequest($request_val); |
---|
487 | if (PEAR::isError($request_data)) { |
---|
488 | $this->_raiseSoapFault($request_data); |
---|
489 | return null; |
---|
490 | } |
---|
491 | $method_response =& $this->callMethod($this->call_methodname, $request_data); |
---|
492 | if (PEAR::isError($method_response)) { |
---|
493 | $this->_raiseSoapFault($method_response); |
---|
494 | return null; |
---|
495 | } |
---|
496 | |
---|
497 | if ($this->_options['parameters'] || |
---|
498 | !$method_response || |
---|
499 | $this->_options['style'] == 'rpc') { |
---|
500 | /* Get the method result. */ |
---|
501 | if (is_null($method_response)) { |
---|
502 | $return_val = null; |
---|
503 | } else { |
---|
504 | $return_val = $this->buildResult($method_response, $this->return_type); |
---|
505 | } |
---|
506 | |
---|
507 | $qn = new QName($this->methodname . 'Response', $this->method_namespace); |
---|
508 | $methodValue = new SOAP_Value($qn->fqn(), 'Struct', $return_val); |
---|
509 | } else { |
---|
510 | $methodValue =& $method_response; |
---|
511 | } |
---|
512 | return $this->makeEnvelope($methodValue, $header_results, $this->response_encoding); |
---|
513 | } |
---|
514 | |
---|
515 | function &__decodeRequest($request, $shift = false) |
---|
516 | { |
---|
517 | if (!$request) { |
---|
518 | $decoded = null; |
---|
519 | return $decoded; |
---|
520 | } |
---|
521 | |
---|
522 | /* Check for valid response. */ |
---|
523 | if (PEAR::isError($request)) { |
---|
524 | $fault = &$this->_raiseSoapFault($request); |
---|
525 | return $fault; |
---|
526 | } else if (!is_a($request, 'SOAP_Value')) { |
---|
527 | $fault = &$this->_raiseSoapFault('Invalid data in server::__decodeRequest'); |
---|
528 | return $fault; |
---|
529 | } |
---|
530 | |
---|
531 | /* Decode to native php datatype. */ |
---|
532 | $requestArray = $this->_decode($request); |
---|
533 | /* Fault? */ |
---|
534 | if (PEAR::isError($requestArray)) { |
---|
535 | $fault = &$this->_raiseSoapFault($requestArray); |
---|
536 | return $fault; |
---|
537 | } |
---|
538 | if (is_object($requestArray) && |
---|
539 | get_class($requestArray) == 'stdClass') { |
---|
540 | $requestArray = get_object_vars($requestArray); |
---|
541 | } elseif ($this->_options['style'] == 'document') { |
---|
542 | $requestArray = array($requestArray); |
---|
543 | } |
---|
544 | if (is_array($requestArray)) { |
---|
545 | if (isset($requestArray['faultcode']) || |
---|
546 | isset($requestArray['SOAP-ENV:faultcode'])) { |
---|
547 | $faultcode = $faultstring = $faultdetail = $faultactor = ''; |
---|
548 | foreach ($requestArray as $k => $v) { |
---|
549 | if (stristr($k, 'faultcode')) { |
---|
550 | $faultcode = $v; |
---|
551 | } |
---|
552 | if (stristr($k, 'faultstring')) { |
---|
553 | $faultstring = $v; |
---|
554 | } |
---|
555 | if (stristr($k, 'detail')) { |
---|
556 | $faultdetail = $v; |
---|
557 | } |
---|
558 | if (stristr($k, 'faultactor')) { |
---|
559 | $faultactor = $v; |
---|
560 | } |
---|
561 | } |
---|
562 | $fault = &$this->_raiseSoapFault($faultstring, $faultdetail, $faultactor, $faultcode); |
---|
563 | return $fault; |
---|
564 | } |
---|
565 | /* Return array of return values. */ |
---|
566 | if ($shift && count($requestArray) == 1) { |
---|
567 | $decoded = array_shift($requestArray); |
---|
568 | return $decoded; |
---|
569 | } |
---|
570 | return $requestArray; |
---|
571 | } |
---|
572 | return $requestArray; |
---|
573 | } |
---|
574 | |
---|
575 | function verifyMethod($request) |
---|
576 | { |
---|
577 | if (!$this->callValidation) { |
---|
578 | return true; |
---|
579 | } |
---|
580 | |
---|
581 | $params = $request->value; |
---|
582 | |
---|
583 | /* Get the dispatch map if one exists. */ |
---|
584 | $map = null; |
---|
585 | if (array_key_exists($this->methodname, $this->dispatch_map)) { |
---|
586 | $map = $this->dispatch_map[$this->methodname]; |
---|
587 | } elseif (isset($this->soapobject)) { |
---|
588 | if (method_exists($this->soapobject, '__dispatch')) { |
---|
589 | $map = $this->soapobject->__dispatch($this->methodname); |
---|
590 | } elseif (method_exists($this->soapobject, $this->methodname)) { |
---|
591 | /* No map, all public functions are SOAP functions. */ |
---|
592 | return true; |
---|
593 | } |
---|
594 | } |
---|
595 | if (!$map) { |
---|
596 | $this->_raiseSoapFault('SOAP request specified an unhandled method "' . $this->methodname . '"', '', '', 'Client'); |
---|
597 | return false; |
---|
598 | } |
---|
599 | |
---|
600 | /* If we aliased the SOAP method name to a PHP function, change |
---|
601 | * call_methodname so we do the right thing. */ |
---|
602 | if (array_key_exists('alias', $map) && !empty($map['alias'])) { |
---|
603 | $this->call_methodname = $map['alias']; |
---|
604 | } |
---|
605 | |
---|
606 | /* If there are input parameters required. */ |
---|
607 | if ($map['in']) { |
---|
608 | $this->input_value = count($map['in']); |
---|
609 | $this->return_type = false; |
---|
610 | if (is_array($map['out'])) { |
---|
611 | $this->return_type = count($map['out']) > 1 |
---|
612 | ? $map['out'] |
---|
613 | : array_shift($map['out']); |
---|
614 | } |
---|
615 | if (is_array($params)) { |
---|
616 | /* Validate the number of parameters. */ |
---|
617 | if (count($params) == count($map['in'])) { |
---|
618 | /* Make array of param types. */ |
---|
619 | foreach ($params as $param) { |
---|
620 | $p[] = strtolower($param->type); |
---|
621 | } |
---|
622 | $sig_t = array_values($map['in']); |
---|
623 | /* Validate each param's type. */ |
---|
624 | for ($i = 0; $i < count($p); $i++) { |
---|
625 | /* If SOAP types do not match, it's still fine if the |
---|
626 | * mapped php types match this allows using plain PHP |
---|
627 | * variables to work (i.e. stuff like Decimal would |
---|
628 | * fail otherwise). We consider this only error if the |
---|
629 | * types exist in our type maps, and they differ. */ |
---|
630 | if (strcasecmp($sig_t[$i], $p[$i]) != 0 && |
---|
631 | isset($this->_typemap[SOAP_XML_SCHEMA_VERSION][$sig_t[$i]]) && |
---|
632 | strcasecmp($this->_typemap[SOAP_XML_SCHEMA_VERSION][$sig_t[$i]], $this->_typemap[SOAP_XML_SCHEMA_VERSION][$p[$i]]) != 0) { |
---|
633 | |
---|
634 | $param = $params[$i]; |
---|
635 | $this->_raiseSoapFault("SOAP request contained mismatching parameters of name $param->name had type [{$p[$i]}], which did not match signature's type: [{$sig_t[$i]}], matched? " . (strcasecmp($sig_t[$i], $p[$i])), '', '', 'Client'); |
---|
636 | return false; |
---|
637 | } |
---|
638 | } |
---|
639 | return true; |
---|
640 | } else { |
---|
641 | /* Wrong number of params. */ |
---|
642 | $this->_raiseSoapFault('SOAP request contained incorrect number of parameters. method "' . $this->methodname . '" required ' . count($map['in']) . ' and request provided ' . count($params), '', '', 'Client'); |
---|
643 | return false; |
---|
644 | } |
---|
645 | } else { |
---|
646 | /* No params. */ |
---|
647 | $this->_raiseSoapFault('SOAP request contained incorrect number of parameters. method "' . $this->methodname . '" requires ' . count($map['in']) . ' parameters, and request provided none.', '', '', 'Client'); |
---|
648 | return false; |
---|
649 | } |
---|
650 | } |
---|
651 | |
---|
652 | /* We'll try it anyway. */ |
---|
653 | return true; |
---|
654 | } |
---|
655 | |
---|
656 | function validateMethod($methodname, $namespace = null) |
---|
657 | { |
---|
658 | unset($this->soapobject); |
---|
659 | |
---|
660 | if (!$this->callValidation) { |
---|
661 | return true; |
---|
662 | } |
---|
663 | |
---|
664 | /* No SOAP access to private functions. */ |
---|
665 | if ($methodname[0] == '_') { |
---|
666 | return false; |
---|
667 | } |
---|
668 | |
---|
669 | /* if it's in our function list, ok */ |
---|
670 | if (array_key_exists($methodname, $this->dispatch_map) && |
---|
671 | (!$namespace || |
---|
672 | !array_key_exists('namespace', $this->dispatch_map[$methodname]) || |
---|
673 | $namespace == $this->dispatch_map[$methodname]['namespace'])) { |
---|
674 | if (array_key_exists('namespace', $this->dispatch_map[$methodname])) |
---|
675 | $this->method_namespace = $this->dispatch_map[$methodname]['namespace']; |
---|
676 | return true; |
---|
677 | } |
---|
678 | |
---|
679 | /* if it's in an object, it's ok */ |
---|
680 | if (isset($this->dispatch_objects[$namespace])) { |
---|
681 | $c = count($this->dispatch_objects[$namespace]); |
---|
682 | for ($i = 0; $i < $c; $i++) { |
---|
683 | $obj =& $this->dispatch_objects[$namespace][$i]; |
---|
684 | /* If we have a dispatch map, and the function is not in the |
---|
685 | * dispatch map, then it is not callable! */ |
---|
686 | if (method_exists($obj, '__dispatch')) { |
---|
687 | if ($obj->__dispatch($methodname)) { |
---|
688 | $this->method_namespace = $namespace; |
---|
689 | $this->soapobject =& $obj; |
---|
690 | return true; |
---|
691 | } |
---|
692 | } elseif (method_exists($obj, $methodname)) { |
---|
693 | $this->method_namespace = $namespace; |
---|
694 | $this->soapobject =& $obj; |
---|
695 | return true; |
---|
696 | } |
---|
697 | } |
---|
698 | } |
---|
699 | |
---|
700 | return false; |
---|
701 | } |
---|
702 | |
---|
703 | function addObjectMap(&$obj, $namespace = null, $service_name = 'Default', |
---|
704 | $service_desc = '') |
---|
705 | { |
---|
706 | if (!$namespace) { |
---|
707 | if (isset($obj->namespace)) { |
---|
708 | // XXX a bit of backwards compatibility |
---|
709 | $namespace = $obj->namespace; |
---|
710 | } else { |
---|
711 | $this->_raiseSoapFault('No namespace provided for class!', '', '', 'Server'); |
---|
712 | return false; |
---|
713 | } |
---|
714 | } |
---|
715 | if (!isset($this->dispatch_objects[$namespace])) { |
---|
716 | $this->dispatch_objects[$namespace] = array(); |
---|
717 | } |
---|
718 | $this->dispatch_objects[$namespace][] =& $obj; |
---|
719 | |
---|
720 | // Create internal WSDL structures for object |
---|
721 | |
---|
722 | // XXX Because some internal workings of PEAR::SOAP decide whether to |
---|
723 | // do certain things by the presence or absence of _wsdl, we should |
---|
724 | // only create a _wsdl structure if we know we can fill it; if |
---|
725 | // __dispatch_map or __typedef for the object is missing, we should |
---|
726 | // avoid creating it. Later, when we are using PHP 5 introspection, we |
---|
727 | // will be able to make the data for all objects without any extra |
---|
728 | // information from the developers, and this condition should be |
---|
729 | // dropped. |
---|
730 | |
---|
731 | // XXX Known issue: if imported WSDL (bindWSDL) or another WSDL source |
---|
732 | // is used to add _wsdl structure information, then addObjectWSDL is |
---|
733 | // used, there is a high possibility of _wsdl data corruption; |
---|
734 | // therefore you should avoid using __dispatch_map/__typedef |
---|
735 | // definitions AND other WSDL data sources in the same service. We |
---|
736 | // exclude classes that don't have __typedefs to allow external WSDL |
---|
737 | // files to be used with classes with no internal type definitions |
---|
738 | // (the types are defined in the WSDL file). When addObjectWSDL is |
---|
739 | // refactored to not cause corruption, this restriction can be |
---|
740 | // relaxed. |
---|
741 | |
---|
742 | // In summary, if you add an object with both a dispatch map and type |
---|
743 | // definitions, then previous WSDL file operation and type definitions |
---|
744 | // will be overwritten. |
---|
745 | if (isset($obj->__dispatch_map) && isset($obj->__typedef)) { |
---|
746 | $this->addObjectWSDL($obj, $namespace, $service_name, $service_desc); |
---|
747 | } |
---|
748 | |
---|
749 | return true; |
---|
750 | } |
---|
751 | |
---|
752 | /** |
---|
753 | * Adds a method to the dispatch map. |
---|
754 | */ |
---|
755 | function addToMap($methodname, $in, $out, $namespace = null, $alias = null) |
---|
756 | { |
---|
757 | if (!$this->callHandler && !function_exists($methodname)) { |
---|
758 | $this->_raiseSoapFault('Error mapping function', '', '', 'Server'); |
---|
759 | return false; |
---|
760 | } |
---|
761 | |
---|
762 | $this->dispatch_map[$methodname]['in'] = $in; |
---|
763 | $this->dispatch_map[$methodname]['out'] = $out; |
---|
764 | $this->dispatch_map[$methodname]['alias'] = $alias; |
---|
765 | if ($namespace) { |
---|
766 | $this->dispatch_map[$methodname]['namespace'] = $namespace; |
---|
767 | } |
---|
768 | |
---|
769 | return true; |
---|
770 | } |
---|
771 | |
---|
772 | function setCallHandler($callHandler, $validation = true) |
---|
773 | { |
---|
774 | $this->callHandler = $callHandler; |
---|
775 | $this->callValidation = $validation; |
---|
776 | } |
---|
777 | |
---|
778 | /** |
---|
779 | * @deprecated use bindWSDL from now on |
---|
780 | */ |
---|
781 | function bind($wsdl_url) |
---|
782 | { |
---|
783 | $this->bindWSDL($wsdl_url); |
---|
784 | } |
---|
785 | |
---|
786 | /** |
---|
787 | * @param string a url to a WSDL resource |
---|
788 | * @return void |
---|
789 | */ |
---|
790 | function bindWSDL($wsdl_url) |
---|
791 | { |
---|
792 | /* Instantiate WSDL class. */ |
---|
793 | $this->_wsdl = new SOAP_WSDL($wsdl_url); |
---|
794 | if ($this->_wsdl->fault) { |
---|
795 | $this->_raiseSoapFault($this->_wsdl->fault); |
---|
796 | } |
---|
797 | } |
---|
798 | |
---|
799 | /** |
---|
800 | * @return void |
---|
801 | */ |
---|
802 | function addObjectWSDL(&$wsdl_obj, $targetNamespace, $service_name, |
---|
803 | $service_desc = '') |
---|
804 | { |
---|
805 | if (!isset($this->_wsdl)) { |
---|
806 | $this->_wsdl = new SOAP_WSDL; |
---|
807 | } |
---|
808 | |
---|
809 | $this->_wsdl->parseObject($wsdl_obj, $targetNamespace, $service_name, $service_desc); |
---|
810 | |
---|
811 | if ($this->_wsdl->fault) { |
---|
812 | $this->_raiseSoapFault($this->_wsdl->fault); |
---|
813 | } |
---|
814 | } |
---|
815 | |
---|
816 | } |
---|