Viewing file: Server.php (30.45 KB) -rw-rw-rw- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php /** * This file contains the code for the SOAP server. * * PHP versions 4 and 5 * * LICENSE: This source file is subject to version 2.02 of the PHP license, * that is bundled with this package in the file LICENSE, and is available at * through the world-wide-web at http://www.php.net/license/2_02.txt. If you * did not receive a copy of the PHP license and are unable to obtain it * through the world-wide-web, please send a note to license@php.net so we can * mail you a copy immediately. * * @category Web Services * @package SOAP * @author Dietrich Ayala <dietrich@ganx4.com> Original Author * @author Shane Caraveo <Shane@Caraveo.com> Port to PEAR and more * @author Chuck Hagenbuch <chuck@horde.org> Maintenance * @author Jan Schneider <jan@horde.org> Maintenance * @copyright 2003-2005 The PHP Group * @license http://www.php.net/license/2_02.txt PHP License 2.02 * @link http://pear.php.net/package/SOAP */
require_once 'SOAP/Base.php'; require_once 'SOAP/Fault.php'; require_once 'SOAP/Parser.php'; require_once 'SOAP/Value.php'; require_once 'SOAP/WSDL.php';
/** * SOAP Server Class * * Originaly based on SOAPx4 by Dietrich Ayala * http://dietrich.ganx4.com/soapx4 * * @access public * @package SOAP * @author Shane Caraveo <shane@php.net> Conversion to PEAR and updates * @author Dietrich Ayala <dietrich@ganx4.com> Original Author */ class SOAP_Server extends SOAP_Base { /** * * @var array */ var $dispatch_map = array(); // create empty dispatch map var $dispatch_objects = array(); var $soapobject = null; var $call_methodname = null; var $callHandler = null; var $callValidation = true;
/** * A list of headers that are going to be sent back to the client. * * @var array */ var $headers = array();
/** * * @var string */ var $request = '';
/** * * @var string XML-Encoding */ var $xml_encoding = SOAP_DEFAULT_ENCODING; var $response_encoding = 'UTF-8';
var $result = 'successful'; // for logging interop results to db
var $endpoint = ''; // the uri to ME!
var $service = ''; //soapaction header var $method_namespace = null;
/** * Options. * * @var array */ var $_options = array('use' => 'encoded', 'style' => 'rpc', 'parameters' => 0, 'http_status_success' => '200 OK', 'http_status_fault' => '500 SOAP Fault');
function SOAP_Server($options = null) { ini_set('track_errors', 1); parent::SOAP_Base('Server');
if (is_array($options)) { if (isset($options['use'])) { $this->_options['use'] = $options['use']; } if (isset($options['style'])) { $this->_options['style'] = $options['style']; } if (isset($options['parameters'])) { $this->_options['parameters'] = $options['parameters']; } } // assume we encode with section 5 $this->_section5 = true; if ($this->_options['use']=='literal') { $this->_section5 = false; } }
/** * Error handler for errors that happen in proxied methods. * * To always return a valid SOAP response even on errors that don't happen * in this code, the errors are catched, transformed to a SOAP fault and * immediately sent to the client. * * @see http://www.php.net/set_error_handler */ function _errorHandler($errno, $errmsg, $filename, $linenum, $vars) { /* The error handler should ignore '0' errors, eg. hidden by @ - see * the set_error_handler manual page. (thanks to Alan Knowles). */ if (!$errno || !error_reporting() || $errno == E_NOTICE || (defined('E_STRICT') && $errno == constant('E_STRICT'))) { return false; }
$this->fault =& new SOAP_Fault($errmsg, 'Server', 'PHP', "Errno: $errno\nFilename: $filename\nLineno: $linenum\n");
$this->_sendResponse(); exit; }
function _getContentEncoding($content_type) { /* Get the character encoding of the incoming request treat incoming * data as UTF-8 if no encoding set. */ $this->xml_encoding = 'UTF-8'; if (strpos($content_type, '=')) { $enc = strtoupper(str_replace('"', '', substr(strstr($content_type, '='), 1))); if (!in_array($enc, $this->_encodings)) { return false; } $this->xml_encoding = $enc; }
return true; }
/** * Parses the request and posts or returns the response. * * @param string $data The SOAP request data. * @param string $endpoint The service endpoint. Determined automatically * if left empty. * @param boolean $test * @param boolean $return Whether to return the SOAP response data * instead of sending it to the client. */ function service($data, $endpoint = '', $test = false, $return = false) { $response = null; $attachments = array(); $useEncoding = 'DIME';
/* Figure out our endpoint. */ $this->endpoint = $endpoint; if (!$test && !$this->endpoint) { /* We'll try to build our endpoint. */ $this->endpoint = 'http://' . $_SERVER['SERVER_NAME']; if ($_SERVER['SERVER_PORT']) { $this->endpoint .= ':' . $_SERVER['SERVER_PORT']; } $this->endpoint .= $_SERVER['SCRIPT_NAME']; }
/* Get the character encoding of the incoming request treat incoming * data as UTF-8 if no encoding set. */ if (isset($_SERVER['CONTENT_TYPE'])) { if (strcasecmp($_SERVER['CONTENT_TYPE'], 'application/dime') == 0) { $this->_decodeDIMEMessage($data, $headers, $attachments); $useEncoding = 'DIME'; } elseif (stristr($_SERVER['CONTENT_TYPE'], 'multipart/related')) { /* This is a mime message, let's decode it. */ $data = 'Content-Type: ' . stripslashes($_SERVER['CONTENT_TYPE']) . "\r\n\r\n" . $data; $this->_decodeMimeMessage($data, $headers, $attachments); $useEncoding = 'Mime'; } if (!isset($headers['content-type'])) { $headers['content-type'] = stripslashes($_SERVER['CONTENT_TYPE']); } if (!$this->fault && !$this->_getContentEncoding($headers['content-type'])) { $this->xml_encoding = SOAP_DEFAULT_ENCODING; /* Found encoding we don't understand; return a fault. */ $this->_raiseSoapFault('Unsupported encoding, use one of ISO-8859-1, US-ASCII, UTF-8', '', '', 'Server'); } }
/* If this is not a POST with Content-Type text/xml, try to return a * WSDL file. */ if (!$this->fault && !$test && ($_SERVER['REQUEST_METHOD'] != 'POST' || strncmp($headers['content-type'], 'text/xml', 8) != 0)) { /* This is not possibly a valid SOAP request, try to return a WSDL * file. */ $this->_raiseSoapFault('Invalid SOAP request, must be POST with content-type: text/xml, got: ' . (isset($headers['content-type']) ? $headers['content-type'] : 'Nothing!'), '', '', 'Server'); }
if (!$this->fault) { /* $response is a SOAP_Msg object. */ $soap_msg = $this->parseRequest($data, $attachments);
/* Handle Mime or DIME encoding. */ /* TODO: DIME decoding should move to the transport, do it here * for now and for ease of getting it done. */ if (count($this->_attachments)) { if ($useEncoding == 'Mime') { $soap_msg = $this->_makeMimeMessage($soap_msg); } else { // default is dime $soap_msg = $this->_makeDIMEMessage($soap_msg); $this->headers['Content-Type'] = 'application/dime'; } if (PEAR::isError($soap_msg)) { return $this->_raiseSoapFault($soap_msg); } }
if (is_array($soap_msg)) { $response = $soap_msg['body']; if (count($soap_msg['headers'])) { $this->headers = $soap_msg['headers']; } } else { $response = $soap_msg; } }
if ($return) { if ($this->fault) { $response = $this->fault->message(); } return $response; }
$this->_sendResponse($response); }
/** * Sends the final HTTP response to the client, including the HTTP header * and the HTTP body. * * If an error happened, it returns a SOAP fault instead of the response * body. * * @param string $response The response body. */ function _sendResponse($response = '') { /* Make distinction between the different SAPIs, running PHP as CGI or * as a module. */ if (stristr(php_sapi_name(), 'cgi') === 0) { $hdrs_type = 'Status:'; } else { $hdrs_type = 'HTTP/1.1'; }
if ($this->fault) { $hdrs = $hdrs_type . ' ' . $this->_options['http_status_fault'] . "\r\n"; $response = $this->fault->message($this->response_encoding); } else { $hdrs = $hdrs_type . ' ' . $this->_options['http_status_success'] . "\r\n"; } header($hdrs);
$this->headers['Server'] = SOAP_LIBRARY_NAME; if (!isset($this->headers['Content-Type'])) { $this->headers['Content-Type'] = 'text/xml; charset=' . $this->response_encoding; } $this->headers['Content-Length'] = strlen($response);
foreach ($this->headers as $k => $v) { header("$k: $v"); $hdrs .= "$k: $v\r\n"; }
$this->response = $hdrs . "\r\n" . $response; print $response; }
function &callMethod($methodname, &$args) { if ($this->callHandler) { $ret = @call_user_func_array($this->callHandler, array($methodname, $args)); return $ret; }
set_error_handler(array($this, '_errorHandler'));
if ($args) { /* Call method with parameters. */ if (isset($this->soapobject) && is_object($this->soapobject)) { $ret = call_user_func_array(array(&$this->soapobject, $methodname), $args); } else { $ret = call_user_func_array($methodname, $args); } } else { /* Call method withour parameters. */ if (is_object($this->soapobject)) { $ret = call_user_func(array(&$this->soapobject, $methodname)); } else { $ret = call_user_func($methodname); } }
restore_error_handler();
return $ret; }
/** * Creates SOAP_Value objects with return values from method. * Uses method signature to determine type. * * @param mixed $method_response The result(s). * @param array|string $type The type(s) of the return value(s). * @param string $return_name The name of the return value. * @param string $namespace The namespace of the return value. * * @return array List of SOAP_Value objects. */ function buildResult(&$method_response, &$return_type, $return_name = 'return', $namespace = '') { if (is_a($method_response, 'SOAP_Value')) { $return_val = array($method_response); } else { if (is_array($return_type) && is_array($method_response)) { $i = 0;
foreach ($return_type as $key => $type) { if (is_numeric($key)) { $key = 'item'; } if (is_a($method_response[$i], 'SOAP_Value')) { $return_val[] =& $method_response[$i++]; } else { $qn =& new QName($key, $namespace); $return_val[] =& new SOAP_Value($qn->fqn(), $type, $method_response[$i++]); } } } else { if (is_array($return_type)) { $keys = array_keys($return_type); if (!is_numeric($keys[0])) { $return_name = $keys[0]; } $values = array_values($return_type); $return_type = $values[0]; } $qn =& new QName($return_name, $namespace); $return_val = array(new SOAP_Value($qn->fqn(), $return_type, $method_response)); } } return $return_val; }
function parseRequest($data = '', $attachments = null) { /* Parse response, get SOAP_Parser object. */ $parser =& new SOAP_Parser($data, $this->xml_encoding, $attachments); /* If fault occurred during message parsing. */ if ($parser->fault) { $this->fault = $parser->fault; return null; }
/* Handle message headers. */ $request_headers = $parser->getHeaders(); $header_results = array();
if ($request_headers) { if (!is_a($request_headers, 'SOAP_Value')) { $this->_raiseSoapFault('Parser did not return SOAP_Value object: ' . $request_headers, '', '', 'Server'); return null; } if ($request_headers->value) { /* Handle headers now. */ foreach ($request_headers->value as $header_val) { $f_exists = $this->validateMethod($header_val->name, $header_val->namespace);
/* TODO: this does not take into account message routing * yet. */ $myactor = !$header_val->actor || $header_val->actor == 'http://schemas.xmlsoap.org/soap/actor/next' || $header_val->actor == $this->endpoint;
if (!$f_exists && $header_val->mustunderstand && $myactor) { $this->_raiseSoapFault('I don\'t understand header ' . $header_val->name, '', '', 'MustUnderstand'); return null; }
/* We only handle the header if it's for us. */ $isok = $f_exists && $myactor;
if ($isok) { /* Call our header now! */ $header_method = $header_val->name; $header_data = array($this->_decode($header_val)); /* If there are parameters to pass. */ $hr =& $this->callMethod($header_method, $header_data); if (PEAR::isError($hr)) { $this->_raiseSoapFault($hr); return null; } $results = $this->buildResult($hr, $this->return_type, $header_method, $header_val->namespace); $header_results[] = $results[0]; } } } }
/* Handle the method call. */ /* Evaluate message, getting back a SOAP_Value object. */ $this->call_methodname = $this->methodname = $parser->root_struct_name[0];
/* Figure out the method namespace. */ $this->method_namespace = $parser->message[$parser->root_struct[0]]['namespace'];
if ($this->_wsdl) { $this->_setSchemaVersion($this->_wsdl->xsd); $dataHandler = $this->_wsdl->getDataHandler($this->methodname, $this->method_namespace); if ($dataHandler) $this->call_methodname = $this->methodname = $dataHandler;
$this->_portName = $this->_wsdl->getPortName($this->methodname); if (PEAR::isError($this->_portName)) { $this->_raiseSoapFault($this->_portName); return null; } $opData = $this->_wsdl->getOperationData($this->_portName, $this->methodname); if (PEAR::isError($opData)) { $this->_raiseSoapFault($opData); return null; } $this->_options['style'] = $opData['style']; $this->_options['use'] = $opData['output']['use']; $this->_options['parameters'] = $opData['parameters']; }
/* Does method exist? */ if (!$this->methodname || !$this->validateMethod($this->methodname, $this->method_namespace)) { $this->_raiseSoapFault('method "' . $this->method_namespace . $this->methodname . '" not defined in service', '', '', 'Server'); return null; }
if (!$request_val = $parser->getResponse()) { return null; } if (!is_a($request_val, 'SOAP_Value')) { $this->_raiseSoapFault('Parser did not return SOAP_Value object: ' . $request_val, '', '', 'Server'); return null; }
/* Verify that SOAP_Value objects in request match the methods * signature. */ if (!$this->verifyMethod($request_val)) { /* verifyMethod() creates the fault. */ return null; }
/* Need to set special error detection inside the value class to * differentiate between no params passed, and an error decoding. */ $request_data = $this->__decodeRequest($request_val); if (PEAR::isError($request_data)) { $this->_raiseSoapFault($request_data); return null; } $method_response =& $this->callMethod($this->call_methodname, $request_data); if (PEAR::isError($method_response)) { $this->_raiseSoapFault($method_response); return null; }
if ($this->_options['parameters'] || !$method_response || $this->_options['style']=='rpc') { /* Get the method result. */ if (is_null($method_response)) { $return_val = null; } else { $return_val = $this->buildResult($method_response, $this->return_type); }
$qn =& new QName($this->methodname . 'Response', $this->method_namespace); $methodValue =& new SOAP_Value($qn->fqn(), 'Struct', $return_val); } else { $methodValue =& $method_response; } return $this->makeEnvelope($methodValue, $header_results, $this->response_encoding); }
function &__decodeRequest($request, $shift = false) { if (!$request) { $decoded = null; return $decoded; }
/* Check for valid response. */ if (PEAR::isError($request)) { $fault = &$this->_raiseSoapFault($request); return $fault; } else if (!is_a($request, 'SOAP_Value')) { $fault = &$this->_raiseSoapFault('Invalid data in server::__decodeRequest'); return $fault; }
/* Decode to native php datatype. */ $requestArray = $this->_decode($request); /* Fault? */ if (PEAR::isError($requestArray)) { $fault = &$this->_raiseSoapFault($requestArray); return $fault; } if (is_object($requestArray) && get_class($requestArray) == 'stdClass') { $requestArray = get_object_vars($requestArray); } elseif ($this->_options['style'] == 'document') { $requestArray = array($requestArray); } if (is_array($requestArray)) { if (isset($requestArray['faultcode']) || isset($requestArray['SOAP-ENV:faultcode'])) { $faultcode = $faultstring = $faultdetail = $faultactor = ''; foreach ($requestArray as $k => $v) { if (stristr($k, 'faultcode')) { $faultcode = $v; } if (stristr($k, 'faultstring')) { $faultstring = $v; } if (stristr($k, 'detail')) { $faultdetail = $v; } if (stristr($k, 'faultactor')) { $faultactor = $v; } } $fault = &$this->_raiseSoapFault($faultstring, $faultdetail, $faultactor, $faultcode); return $fault; } /* Return array of return values. */ if ($shift && count($requestArray) == 1) { $decoded = array_shift($requestArray); return $decoded; } return $requestArray; } return $requestArray; }
function verifyMethod($request) { if (!$this->callValidation) { return true; }
$params = $request->value;
/* Get the dispatch map if one exists. */ $map = null; if (array_key_exists($this->methodname, $this->dispatch_map)) { $map = $this->dispatch_map[$this->methodname]; } elseif (isset($this->soapobject)) { if (method_exists($this->soapobject, '__dispatch')) { $map = $this->soapobject->__dispatch($this->methodname); } elseif (method_exists($this->soapobject, $this->methodname)) { /* No map, all public functions are SOAP functions. */ return true; } } if (!$map) { $this->_raiseSoapFault('SOAP request specified an unhandled method "' . $this->methodname . '"', '', '', 'Client'); return false; }
/* If we aliased the SOAP method name to a PHP function, change * call_methodname so we do the right thing. */ if (array_key_exists('alias', $map) && !empty($map['alias'])) { $this->call_methodname = $map['alias']; }
/* If there are input parameters required. */ if ($sig = $map['in']) { $this->input_value = count($sig); $this->return_type = false; if (is_array($map['out'])) { $this->return_type = count($map['out']) > 1 ? $map['out'] : array_shift($map['out']); } if (is_array($params)) { /* Validate the number of parameters. */ if (count($params) == count($sig)) { /* Make array of param types. */ foreach ($params as $param) { $p[] = strtolower($param->type); } $sig_t = array_values($sig); /* Validate each param's type. */ for ($i = 0; $i < count($p); $i++) { /* If SOAP types do not match, it's still fine if the * mapped php types match this allows using plain PHP * variables to work (i.e. stuff like Decimal would * fail otherwise). We consider this only error if the * types exist in our type maps, and they differ. */ if (strcasecmp($sig_t[$i], $p[$i]) != 0 && isset($this->_typemap[SOAP_XML_SCHEMA_VERSION][$sig_t[$i]]) && strcasecmp($this->_typemap[SOAP_XML_SCHEMA_VERSION][$sig_t[$i]], $this->_typemap[SOAP_XML_SCHEMA_VERSION][$p[$i]]) != 0) {
$param = $params[$i]; $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'); return false; } } return true; } else { /* Wrong number of params. */ $this->_raiseSoapFault('SOAP request contained incorrect number of parameters. method "' . $this->methodname . '" required ' . count($sig) . ' and request provided ' . count($params), '', '', 'Client'); return false; } } else { /* No params. */ $this->_raiseSoapFault('SOAP request contained incorrect number of parameters. method "' . $this->methodname . '" requires ' . count($sig) . ' parameters, and request provided none.', '', '', 'Client'); return false; } }
/* We'll try it anyway. */ return true; }
function validateMethod($methodname, $namespace = null) { unset($this->soapobject);
if (!$this->callValidation) { return true; }
/* No SOAP access to private functions. */ if ($methodname[0] == '_') { return false; }
/* if it's in our function list, ok */ if (array_key_exists($methodname, $this->dispatch_map) && (!$namespace || !array_key_exists('namespace', $this->dispatch_map[$methodname]) || $namespace == $this->dispatch_map[$methodname]['namespace'])) { if (array_key_exists('namespace', $this->dispatch_map[$methodname])) $this->method_namespace = $this->dispatch_map[$methodname]['namespace']; return true; }
/* if it's in an object, it's ok */ if (isset($this->dispatch_objects[$namespace])) { $c = count($this->dispatch_objects[$namespace]); for ($i = 0; $i < $c; $i++) { $obj =& $this->dispatch_objects[$namespace][$i]; /* If we have a dispatch map, and the function is not in the * dispatch map, then it is not callable! */ if (method_exists($obj, '__dispatch')) { if ($obj->__dispatch($methodname)) { $this->method_namespace = $namespace; $this->soapobject =& $obj; return true; } } elseif (method_exists($obj, $methodname)) { $this->method_namespace = $namespace; $this->soapobject =& $obj; return true; } } }
return false; }
function addObjectMap(&$obj, $namespace = null, $service_name = 'Default', $service_desc = '') { if (!$namespace) { if (isset($obj->namespace)) { // XXX a bit of backwards compatibility $namespace = $obj->namespace; } else { $this->_raiseSoapFault('No namespace provided for class!', '', '', 'Server'); return false; } } if (!isset($this->dispatch_objects[$namespace])) { $this->dispatch_objects[$namespace] = array(); } $this->dispatch_objects[$namespace][] =& $obj;
// Create internal WSDL structures for object
// XXX Because some internal workings of PEAR::SOAP decide whether to // do certain things by the presence or absence of _wsdl, we should // only create a _wsdl structure if we know we can fill it; if // __dispatch_map or __typedef for the object is missing, we should // avoid creating it. Later, when we are using PHP 5 introspection, we // will be able to make the data for all objects without any extra // information from the developers, and this condition should be // dropped.
// XXX Known issue: if imported WSDL (bindWSDL) or another WSDL source // is used to add _wsdl structure information, then addObjectWSDL is // used, there is a high possibility of _wsdl data corruption; // therefore you should avoid using __dispatch_map/__typedef // definitions AND other WSDL data sources in the same service. We // exclude classes that don't have __typedefs to allow external WSDL // files to be used with classes with no internal type definitions // (the types are defined in the WSDL file). When addObjectWSDL is // refactored to not cause corruption, this restriction can be // relaxed.
// In summary, if you add an object with both a dispatch map and type // definitions, then previous WSDL file operation and type definitions // will be overwritten. if (isset($obj->__dispatch_map) && isset($obj->__typedef)) { $this->addObjectWSDL($obj, $namespace, $service_name, $service_desc); }
return true; }
/** * Adds a method to the dispatch map. */ function addToMap($methodname, $in, $out, $namespace = null, $alias = null) { if (!$this->callHandler && !function_exists($methodname)) { $this->_raiseSoapFault('Error mapping function', '', '', 'Server'); return false; }
$this->dispatch_map[$methodname]['in'] = $in; $this->dispatch_map[$methodname]['out'] = $out; $this->dispatch_map[$methodname]['alias'] = $alias; if ($namespace) { $this->dispatch_map[$methodname]['namespace'] = $namespace; }
return true; }
function setCallHandler($callHandler, $validation = true) { $this->callHandler = $callHandler; $this->callValidation = $validation; }
/** * @deprecated use bindWSDL from now on */ function bind($wsdl_url) { $this->bindWSDL($wsdl_url); }
/** * @param string a url to a WSDL resource * @return void */ function bindWSDL($wsdl_url) { /* Instantiate WSDL class. */ $this->_wsdl =& new SOAP_WSDL($wsdl_url); if ($this->_wsdl->fault) { $this->_raiseSoapFault($this->_wsdl->fault); } }
/** * @return void */ function addObjectWSDL(&$wsdl_obj, $targetNamespace, $service_name, $service_desc = '') { if (!isset($this->_wsdl)) { $this->_wsdl =& new SOAP_WSDL; }
$this->_wsdl->parseObject($wsdl_obj, $targetNamespace, $service_name, $service_desc);
if ($this->_wsdl->fault) { $this->_raiseSoapFault($this->_wsdl->fault); } } }
|