Original Author
+ */
+class SOAP_Client extends SOAP_Client_Overload
+{
+ /**
+ * Communication endpoint.
+ *
+ * Currently the following transport formats are supported:
+ * - HTTP
+ * - SMTP
+ *
+ * Example endpoints:
+ * http://www.example.com/soap/server.php
+ * https://www.example.com/soap/server.php
+ * mailto:soap@example.com
+ *
+ * @see SOAP_Client()
+ * @var string
+ */
+ var $_endpoint = '';
+
+ /**
+ * The SOAP PORT name that is used by the client.
+ *
+ * @var string
+ */
+ var $_portName = '';
+
+ /**
+ * Endpoint type e.g. 'wdsl'.
+ *
+ * @var string
+ */
+ var $_endpointType = '';
+
+ /**
+ * The received xml.
+ *
+ * @var string
+ */
+ var $xml;
+
+ /**
+ * The outgoing and incoming data stream for debugging.
+ *
+ * @var string
+ */
+ var $wire;
+
+ /**
+ * The outgoing data stream for debugging.
+ *
+ * @var string
+ */
+ var $_last_request = null;
+
+ /**
+ * The incoming data stream for debugging.
+ *
+ * @var string
+ */
+ var $_last_response = null;
+
+ /**
+ * Options.
+ *
+ * @var array
+ */
+ var $_options = array('trace' => false);
+
+ /**
+ * The character encoding used for XML parser, etc.
+ *
+ * @var string
+ */
+ var $_encoding = SOAP_DEFAULT_ENCODING;
+
+ /**
+ * The array of SOAP_Headers that we are sending.
+ *
+ * @var array
+ */
+ var $headersOut = null;
+
+ /**
+ * The headers we recieved back in the response.
+ *
+ * @var array
+ */
+ var $headersIn = null;
+
+ /**
+ * Options for the HTTP_Request class (see HTTP/Request.php).
+ *
+ * @var array
+ */
+ var $_proxy_params = array();
+
+ /**
+ * The SOAP_Transport instance.
+ *
+ * @var SOAP_Transport
+ */
+ var $_soap_transport = null;
+
+ /**
+ * Constructor.
+ *
+ * @access public
+ *
+ * @param string $endpoint An URL.
+ * @param boolean $wsdl Whether the endpoint is a WSDL file.
+ * @param string $portName The service's port name to use.
+ * @param array $proxy_params Options for the HTTP_Request class
+ * @see HTTP_Request
+ * @param boolean|string $cache Use WSDL caching? The cache directory if
+ * a string.
+ */
+ function SOAP_Client($endpoint, $wsdl = false, $portName = false,
+ $proxy_params = array(), $cache = false)
+ {
+ parent::SOAP_Base('Client');
+
+ $this->_endpoint = $endpoint;
+ $this->_portName = $portName;
+ $this->_proxy_params = $proxy_params;
+
+ // This hack should perhaps be removed as it might cause unexpected
+ // behaviour.
+ $wsdl = $wsdl
+ ? $wsdl
+ : strtolower(substr($endpoint, -4)) == 'wsdl';
+
+ // make values
+ if ($wsdl) {
+ $this->_endpointType = 'wsdl';
+ // instantiate wsdl class
+ $this->_wsdl = new SOAP_WSDL($this->_endpoint,
+ $this->_proxy_params,
+ $cache);
+ if ($this->_wsdl->fault) {
+ $this->_raiseSoapFault($this->_wsdl->fault);
+ }
+ }
+ }
+
+ function _reset()
+ {
+ $this->xml = null;
+ $this->wire = null;
+ $this->_last_request = null;
+ $this->_last_response = null;
+ $this->headersIn = null;
+ $this->headersOut = null;
+ }
+
+ /**
+ * Sets the character encoding.
+ *
+ * Limited to 'UTF-8', 'US_ASCII' and 'ISO-8859-1'.
+ *
+ * @access public
+ *
+ * @param string encoding
+ *
+ * @return mixed SOAP_Fault on error.
+ */
+ function setEncoding($encoding)
+ {
+ if (in_array($encoding, $this->_encodings)) {
+ $this->_encoding = $encoding;
+ return;
+ }
+ return $this->_raiseSoapFault('Invalid Encoding');
+ }
+
+ /**
+ * Adds a header to the envelope.
+ *
+ * @access public
+ *
+ * @param SOAP_Header $soap_value A SOAP_Header or an array with the
+ * elements 'name', 'namespace',
+ * 'mustunderstand', and 'actor' to send
+ * as a header.
+ */
+ function addHeader($soap_value)
+ {
+ // Add a new header to the message.
+ if (is_a($soap_value, 'SOAP_Header')) {
+ $this->headersOut[] = $soap_value;
+ } elseif (is_array($soap_value)) {
+ // name, value, namespace, mustunderstand, actor
+ $this->headersOut[] = new SOAP_Header($soap_value[0],
+ null,
+ $soap_value[1],
+ $soap_value[2],
+ $soap_value[3]);
+ } else {
+ $this->_raiseSoapFault('Invalid parameter provided to addHeader(). Must be an array or a SOAP_Header.');
+ }
+ }
+
+ /**
+ * Calls a method on the SOAP endpoint.
+ *
+ * The namespace parameter is overloaded to accept an array of options
+ * that can contain data necessary for various transports if it is used as
+ * an array, it MAY contain a namespace value and a soapaction value. If
+ * it is overloaded, the soapaction parameter is ignored and MUST be
+ * placed in the options array. This is done to provide backwards
+ * compatibility with current clients, but may be removed in the future.
+ * The currently supported values are:
+ * namespace
+ * soapaction
+ * timeout (HTTP socket timeout)
+ * transfer-encoding (SMTP, Content-Transfer-Encoding: header)
+ * from (SMTP, From: header)
+ * subject (SMTP, Subject: header)
+ * headers (SMTP, hash of extra SMTP headers)
+ *
+ *
+ * @access public
+ *
+ * @param string $method The method to call.
+ * @param array $params The method parameters.
+ * @param string|array $namespace Namespace or hash with options.
+ * @param string $soapAction
+ *
+ * @return mixed The method result or a SOAP_Fault on error.
+ */
+ function &call($method, &$params, $namespace = false, $soapAction = false)
+ {
+ $this->headersIn = null;
+ $this->_last_request = null;
+ $this->_last_response = null;
+ $this->wire = null;
+ $this->xml = null;
+
+ $soap_data = $this->_generate($method, $params, $namespace, $soapAction);
+ if (PEAR::isError($soap_data)) {
+ $fault = $this->_raiseSoapFault($soap_data);
+ return $fault;
+ }
+
+ // _generate() may have changed the endpoint if the WSDL has more
+ // than one service, so we need to see if we need to generate a new
+ // transport to hook to a different URI. Since the transport protocol
+ // can also change, we need to get an entirely new object. This could
+ // probably be optimized.
+ if (!$this->_soap_transport ||
+ $this->_endpoint != $this->_soap_transport->url) {
+ $this->_soap_transport =& SOAP_Transport::getTransport($this->_endpoint);
+ if (PEAR::isError($this->_soap_transport)) {
+ $fault =& $this->_soap_transport;
+ $this->_soap_transport = null;
+ $fault = $this->_raiseSoapFault($fault);
+ return $fault;
+ }
+ }
+ $this->_soap_transport->encoding = $this->_encoding;
+
+ // Send the message.
+ $transport_options = array_merge_recursive($this->_proxy_params,
+ $this->_options);
+ $this->xml = $this->_soap_transport->send($soap_data, $transport_options);
+
+ // Save the wire information for debugging.
+ if ($this->_options['trace']) {
+ $this->_last_request = $this->_soap_transport->outgoing_payload;
+ $this->_last_response = $this->_soap_transport->incoming_payload;
+ $this->wire = $this->getWire();
+ }
+ if ($this->_soap_transport->fault) {
+ $fault = $this->_raiseSoapFault($this->xml);
+ return $fault;
+ }
+
+ if (isset($this->_options['result']) &&
+ $this->_options['result'] != 'parse') {
+ return $this->xml;
+ }
+
+ $this->__result_encoding = $this->_soap_transport->result_encoding;
+
+ $result = &$this->parseResponse($this->xml, $this->__result_encoding,
+ $this->_soap_transport->attachments);
+ return $result;
+ }
+
+ /**
+ * Sets an option to use with the transport layers.
+ *
+ * For example:
+ *
+ * $soapclient->setOpt('curl', CURLOPT_VERBOSE, 1)
+ *
+ * to pass a specific option to curl if using an SSL connection.
+ *
+ * @access public
+ *
+ * @param string $category Category to which the option applies or option
+ * name.
+ * @param string $option An option name if $category is a category name,
+ * an option value if $category is an option name.
+ * @param string $value An option value if $category is a category
+ * name.
+ */
+ function setOpt($category, $option, $value = null)
+ {
+ if (!is_null($value)) {
+ if (!isset($this->_options[$category])) {
+ $this->_options[$category] = array();
+ }
+ $this->_options[$category][$option] = $value;
+ } else {
+ $this->_options[$category] = $option;
+ }
+ }
+
+ /**
+ * Call method supporting the overload extension.
+ *
+ * If the overload extension is loaded, you can call the client class with
+ * a soap method name:
+ *
+ * $soap = new SOAP_Client(....);
+ * $value = $soap->getStockQuote('MSFT');
+ *
+ *
+ * @access public
+ *
+ * @param string $method The method to call.
+ * @param array $params The method parameters.
+ * @param mixed $return_value Will get the method's return value
+ * assigned.
+ *
+ * @return boolean Always true.
+ */
+ function _call($method, $params, &$return_value)
+ {
+ // Overloading lowercases the method name, we need to look into the
+ // WSDL and try to find the correct method name to get the correct
+ // case for the call.
+ if ($this->_wsdl) {
+ $this->_wsdl->matchMethod($method);
+ }
+
+ $return_value =& $this->call($method, $params);
+
+ return true;
+ }
+
+ /**
+ * @deprecated Use getLastRequest().
+ */
+ function &__getlastrequest()
+ {
+ $request = $this->getLastRequest();
+ return $request;
+ }
+
+ /**
+ * Returns the XML content of the last SOAP request.
+ *
+ * @return string The last request.
+ */
+ function getLastRequest()
+ {
+ return $this->_last_request;
+ }
+
+ /**
+ * @deprecated Use getLastResponse().
+ */
+ function &__getlastresponse()
+ {
+ $response =& $this->getLastResponse;
+ return $response;
+ }
+
+ /**
+ * Returns the XML content of the last SOAP response.
+ *
+ * @return string The last response.
+ */
+ function getLastResponse()
+ {
+ return $this->_last_response;
+ }
+
+ /**
+ * @deprecated Use setUse().
+ */
+ function __use($use)
+ {
+ $this->setUse($use);
+ }
+
+ /**
+ * Sets the SOAP encoding.
+ *
+ * @param string $use Either 'literal' or 'encoded' (section 5).
+ */
+ function setUse($use)
+ {
+ $this->_options['use'] = $use;
+ }
+
+ /**
+ * @deprecated Use setStyle().
+ */
+ function __style($style)
+ {
+ $this->setStyle($style);
+ }
+
+ /**
+ * Sets the SOAP encoding style.
+ *
+ * @param string $style Either 'document' or 'rpc'.
+ */
+ function setStyle($style)
+ {
+ $this->_options['style'] = $style;
+ }
+
+ /**
+ * @deprecated Use setTrace().
+ */
+ function __trace($level)
+ {
+ $this->setTrace($level);
+ }
+
+ /**
+ * Sets whether to trace the traffic on the transport level.
+ *
+ * @see getWire()
+ *
+ * @param boolean $trace
+ */
+ function setTrace($trace)
+ {
+ $this->_options['trace'] = $trace;
+ }
+
+ function _generate($method, &$params, $namespace = false,
+ $soapAction = false)
+ {
+ $this->fault = null;
+ $this->_options['input'] = 'parse';
+ $this->_options['result'] = 'parse';
+ $this->_options['parameters'] = false;
+
+ if ($params && gettype($params) != 'array') {
+ $params = array($params);
+ }
+
+ if (gettype($namespace) == 'array') {
+ foreach ($namespace as $optname => $opt) {
+ $this->_options[strtolower($optname)] = $opt;
+ }
+ if (isset($this->_options['namespace'])) {
+ $namespace = $this->_options['namespace'];
+ } else {
+ $namespace = false;
+ }
+ } else {
+ // We'll place $soapAction into our array for usage in the
+ // transport.
+ $this->_options['soapaction'] = $soapAction;
+ $this->_options['namespace'] = $namespace;
+ }
+
+ if ($this->_endpointType == 'wsdl') {
+ $this->_setSchemaVersion($this->_wsdl->xsd);
+
+ // Get port name.
+ if (!$this->_portName) {
+ $this->_portName = $this->_wsdl->getPortName($method);
+ }
+ if (PEAR::isError($this->_portName)) {
+ return $this->_raiseSoapFault($this->_portName);
+ }
+
+ // Get endpoint.
+ $this->_endpoint = $this->_wsdl->getEndpoint($this->_portName);
+ if (PEAR::isError($this->_endpoint)) {
+ return $this->_raiseSoapFault($this->_endpoint);
+ }
+
+ // Get operation data.
+ $opData = $this->_wsdl->getOperationData($this->_portName, $method);
+
+ if (PEAR::isError($opData)) {
+ return $this->_raiseSoapFault($opData);
+ }
+ $namespace = $opData['namespace'];
+ $this->_options['style'] = $opData['style'];
+ $this->_options['use'] = $opData['input']['use'];
+ $this->_options['soapaction'] = $opData['soapAction'];
+
+ // Set input parameters.
+ if ($this->_options['input'] == 'parse') {
+ $this->_options['parameters'] = $opData['parameters'];
+ $nparams = array();
+ if (isset($opData['input']['parts']) &&
+ count($opData['input']['parts'])) {
+ foreach ($opData['input']['parts'] as $name => $part) {
+ $xmlns = '';
+ $attrs = array();
+ // Is the name a complex type?
+ if (isset($part['element'])) {
+ $xmlns = $this->_wsdl->namespaces[$part['namespace']];
+ $part = $this->_wsdl->elements[$part['namespace']][$part['type']];
+ $name = $part['name'];
+ }
+ if (isset($params[$name]) ||
+ $this->_wsdl->getDataHandler($name, $part['namespace'])) {
+ $nparams[$name] =& $params[$name];
+ } else {
+ // We now force an associative array for
+ // parameters if using WSDL.
+ return $this->_raiseSoapFault("The named parameter $name is not in the call parameters.");
+ }
+ if (gettype($nparams[$name]) != 'object' ||
+ !is_a($nparams[$name], 'SOAP_Value')) {
+ // Type is likely a qname, split it apart, and get
+ // the type namespace from WSDL.
+ $qname = new QName($part['type']);
+ if ($qname->ns) {
+ $type_namespace = $this->_wsdl->namespaces[$qname->ns];
+ } elseif (isset($part['namespace'])) {
+ $type_namespace = $this->_wsdl->namespaces[$part['namespace']];
+ } else {
+ $type_namespace = null;
+ }
+ $qname->namespace = $type_namespace;
+ $pqname = $name;
+ if ($xmlns) {
+ $pqname = '{' . $xmlns . '}' . $name;
+ }
+ $nparams[$name] = new SOAP_Value($pqname,
+ $qname->fqn(),
+ $nparams[$name],
+ $attrs);
+ } else {
+ // WSDL fixups to the SOAP value.
+ }
+ }
+ }
+ $params =& $nparams;
+ unset($nparams);
+ }
+ } else {
+ $this->_setSchemaVersion(SOAP_XML_SCHEMA_VERSION);
+ }
+
+ // Serialize the message.
+ $this->_section5 = (!isset($this->_options['use']) ||
+ $this->_options['use'] != 'literal');
+
+ if (!isset($this->_options['style']) ||
+ $this->_options['style'] == 'rpc') {
+ $this->_options['style'] = 'rpc';
+ $this->docparams = true;
+ $mqname = new QName($method, $namespace);
+ $methodValue = new SOAP_Value($mqname->fqn(), 'Struct', $params);
+ $soap_msg = $this->makeEnvelope($methodValue,
+ $this->headersOut,
+ $this->_encoding,
+ $this->_options);
+ } else {
+ if (!$params) {
+ $mqname = new QName($method, $namespace);
+ $mynull = null;
+ $params = new SOAP_Value($mqname->fqn(), 'Struct', $mynull);
+ } elseif ($this->_options['input'] == 'parse') {
+ if (is_array($params)) {
+ $nparams = array();
+ $keys = array_keys($params);
+ foreach ($keys as $k) {
+ if (gettype($params[$k]) != 'object') {
+ $nparams[] = new SOAP_Value($k,
+ false,
+ $params[$k]);
+ } else {
+ $nparams[] =& $params[$k];
+ }
+ }
+ $params =& $nparams;
+ }
+ if ($this->_options['parameters']) {
+ $mqname = new QName($method, $namespace);
+ $params = new SOAP_Value($mqname->fqn(),
+ 'Struct',
+ $params);
+ }
+ }
+ $soap_msg = $this->makeEnvelope($params,
+ $this->headersOut,
+ $this->_encoding,
+ $this->_options);
+ }
+ unset($this->headersOut);
+
+ if (PEAR::isError($soap_msg)) {
+ return $this->_raiseSoapFault($soap_msg);
+ }
+
+ // Handle MIME or DIME encoding.
+ // TODO: DIME encoding should move to the transport, do it here for
+ // now and for ease of getting it done.
+ if (count($this->_attachments)) {
+ if ((isset($this->_options['attachments']) &&
+ $this->_options['attachments'] == 'Mime') ||
+ isset($this->_options['Mime'])) {
+ $soap_msg = $this->_makeMimeMessage($soap_msg, $this->_encoding);
+ } else {
+ // default is dime
+ $soap_msg = $this->_makeDIMEMessage($soap_msg, $this->_encoding);
+ $this->_options['headers']['Content-Type'] = 'application/dime';
+ }
+ if (PEAR::isError($soap_msg)) {
+ return $this->_raiseSoapFault($soap_msg);
+ }
+ }
+
+ // Instantiate client.
+ if (is_array($soap_msg)) {
+ $soap_data = $soap_msg['body'];
+ if (count($soap_msg['headers'])) {
+ if (isset($this->_options['headers'])) {
+ $this->_options['headers'] = array_merge($this->_options['headers'], $soap_msg['headers']);
+ } else {
+ $this->_options['headers'] = $soap_msg['headers'];
+ }
+ }
+ } else {
+ $soap_data = $soap_msg;
+ }
+
+ return $soap_data;
+ }
+
+ /**
+ * @deprecated Use parseResponse().
+ */
+ function &__parse(&$response, $encoding, &$attachments)
+ {
+ return $this->parseResponse($response, $encoding, $attachments);
+ }
+
+ /**
+ * Parses a SOAP response.
+ *
+ * @see SOAP_Parser::
+ *
+ * @param string $response XML content of SOAP response.
+ * @param string $encoding Character set encoding, defaults to 'UTF-8'.
+ * @param array $attachments List of attachments.
+ */
+ function &parseResponse($response, $encoding, &$attachments)
+ {
+ // Parse the response.
+ $response =& new SOAP_Parser($response, $encoding, $attachments);
+ if ($response->fault) {
+ $fault =& $this->_raiseSoapFault($response->fault);
+ return $fault;
+ }
+
+ // Return array of parameters.
+ $return =& $response->getResponse();
+ $headers =& $response->getHeaders();
+ if ($headers) {
+ $this->headersIn =& $this->_decodeResponse($headers, false);
+ }
+
+ $decoded = &$this->_decodeResponse($return);
+ return $decoded;
+ }
+
+ /**
+ * Converts a complex SOAP_Value into a PHP Array
+ *
+ * @param SOAP_Value $response value object
+ * @param boolean $shift FIXME
+ * @return Array
+ */
+ function &_decodeResponse($response, $shift = true)
+ {
+ if (!$response) {
+ $decoded = null;
+ return $decoded;
+ }
+
+ // Check for valid response.
+ if (PEAR::isError($response)) {
+ $fault =& $this->_raiseSoapFault($response);
+ return $fault;
+ } elseif (!is_a($response, 'soap_value')) {
+ $fault =& $this->_raiseSoapFault("Didn't get SOAP_Value object back from client");
+ return $fault;
+ }
+
+ // Decode to native php datatype.
+ $returnArray =& $this->_decode($response);
+
+ // Fault?
+ if (PEAR::isError($returnArray)) {
+ $fault =& $this->_raiseSoapFault($returnArray);
+ return $fault;
+ }
+
+ if (is_object($returnArray) &&
+ strcasecmp(get_class($returnArray), 'stdClass') == 0) {
+ $returnArray = get_object_vars($returnArray);
+ }
+ if (is_array($returnArray)) {
+ if (isset($returnArray['faultcode']) ||
+ isset($returnArray['SOAP-ENV:faultcode'])) {
+ $faultcode = $faultstring = $faultdetail = $faultactor = '';
+ foreach ($returnArray 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($returnArray) == 1) {
+ $decoded = array_shift($returnArray);
+ return $decoded;
+ }
+ return $returnArray;
+ }
+ return $returnArray;
+ }
+
+ /**
+ * @deprecated Use getWire().
+ */
+ function __get_wire()
+ {
+ return $this->getWire();
+ }
+
+ /**
+ * Returns the outgoing and incoming traffic on the transport level.
+ *
+ * Tracing has to be enabled.
+ *
+ * @see setTrace()
+ *
+ * @return string The complete traffic between the client and the server.
+ */
+ function getWire()
+ {
+ if ($this->_options['trace'] &&
+ ($this->_last_request || $this->_last_response)) {
+ return "OUTGOING:\n\n" .
+ $this->_last_request .
+ "\n\nINCOMING\n\n" .
+ preg_replace("/>\r\n<", $this->_last_response);
+ }
+
+ return null;
+ }
+
+}
Index: branches/feature-module-update/data/module/SOAP/Server/TCP.php
===================================================================
--- branches/feature-module-update/data/module/SOAP/Server/TCP.php (revision 16957)
+++ branches/feature-module-update/data/module/SOAP/Server/TCP.php (revision 16957)
@@ -0,0 +1,106 @@
+ Port to PEAR and more
+ * @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/Server.php';
+
+/**
+ * SOAP Server Class that implements a TCP SOAP Server.
+ * http://www.pocketsoap.com/specs/smtpbinding/
+ *
+ * This class overrides the default HTTP server, providing the ability to
+ * accept socket connections and execute SOAP calls.
+ *
+ * TODO:
+ * use Net_Socket
+ * implement some security scheme
+ * implement support for attachments
+ *
+ * @access public
+ * @package SOAP
+ * @author Shane Caraveo
+ */
+class SOAP_Server_TCP extends SOAP_Server {
+
+ var $headers = array();
+ var $localaddr;
+ var $port;
+ var $listen;
+ var $reuse;
+
+ function SOAP_Server_TCP($localaddr = '127.0.0.1', $port = 10000,
+ $listen = 5, $reuse = true)
+ {
+ parent::SOAP_Server();
+ $this->localaddr = $localaddr;
+ $this->port = $port;
+ $this->listen = $listen;
+ $this->reuse = $reuse;
+ }
+
+ function run()
+ {
+ if (($sock = socket_create(AF_INET, SOCK_STREAM, 0)) < 0) {
+ return $this->_raiseSoapFault('socket_create() failed. Reason: ' . socket_strerror($sock));
+ }
+ if ($this->reuse &&
+ !@socket_setopt($sock, SOL_SOCKET, SO_REUSEADDR, 1)) {
+ return $this->_raiseSoapFault('socket_setopt() failed. Reason: ' . socket_strerror(socket_last_error($sock)));
+ }
+ if (($ret = socket_bind($sock, $this->localaddr, $this->port)) < 0) {
+ return $this->_raiseSoapFault('socket_bind() failed. Reason: ' . socket_strerror($ret));
+ }
+ if (($ret = socket_listen($sock, $this->listen)) < 0) {
+ return $this->_raiseSoapFault('socket_listen() failed. Reason: ' . socket_strerror($ret));
+ }
+
+ while (true) {
+ $data = null;
+ if (($msgsock = socket_accept($sock)) < 0) {
+ $this->_raiseSoapFault('socket_accept() failed. Reason: ' . socket_strerror($msgsock));
+ break;
+ }
+ while ($buf = socket_read($msgsock, 8192)) {
+ if (!$buf = trim($buf)) {
+ continue;
+ }
+ $data .= $buf;
+ }
+
+ if ($data) {
+ $response = $this->service($data);
+ /* Write to the socket. */
+ if (!socket_write($msgsock, $response, strlen($response))) {
+ return $this->_raiseSoapFault('Error sending response data reason ' . socket_strerror());
+ }
+ }
+
+ socket_close ($msgsock);
+ }
+
+ socket_close ($sock);
+ }
+
+ function service(&$data)
+ {
+ /* TODO: we need to handle attachments somehow. */
+ return $this->parseRequest($data, $attachments);
+ }
+}
Index: branches/feature-module-update/data/module/SOAP/Server/Email.php
===================================================================
--- branches/feature-module-update/data/module/SOAP/Server/Email.php (revision 16957)
+++ branches/feature-module-update/data/module/SOAP/Server/Email.php (revision 16957)
@@ -0,0 +1,198 @@
+ Port to PEAR and more
+ * @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/Server.php';
+require_once 'SOAP/Client.php';
+require_once 'SOAP/Transport.php';
+require_once 'Mail/mimeDecode.php';
+
+/**
+ * SOAP Server Class that implements an email SOAP server.
+ * http://www.pocketsoap.com/specs/smtpbinding/
+ *
+ * This class overrides the default HTTP server, providing the ability to
+ * parse an email message and execute SOAP calls. This class DOES NOT pop the
+ * message; the message, complete with headers, must be passed in as a
+ * parameter to the service function call.
+ *
+ * @access public
+ * @package SOAP
+ * @author Shane Caraveo
+ */
+class SOAP_Server_Email extends SOAP_Server {
+
+ var $headers = array();
+
+ function SOAP_Server_Email($send_response = true)
+ {
+ parent::SOAP_Server();
+ $this->send_response = $send_response;
+ }
+
+ /**
+ * Removes HTTP headers from response.
+ *
+ * TODO: use PEAR email classes
+ *
+ * @return boolean
+ * @access private
+ */
+ function _parseEmail(&$data)
+ {
+ if (preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $data, $match)) {
+
+ if (preg_match_all('/^(.*?):\s+(.*)$/m', $match[1], $matches)) {
+ $hc = count($matches[0]);
+ for ($i = 0; $i < $hc; $i++) {
+ $this->headers[strtolower($matches[1][$i])] = trim($matches[2][$i]);
+ }
+ }
+
+ if (!stristr($this->headers['content-type'], 'text/xml')) {
+ $this->_raiseSoapFault('Invalid Content Type', '', '', 'Client');
+ return false;
+ }
+
+ if (strcasecmp($this->headers['content-transfer-encoding'], 'base64')==0) {
+ /* Unfold lines. */
+ $enctext = preg_replace("/[\r|\n]/", '', $match[2]);
+ $data = base64_decode($enctext);
+ } else {
+ $data = $match[2];
+ }
+
+ /* If no content, return false. */
+ return strlen($this->request) > 0;
+ }
+
+ $this->_raiseSoapFault('Invalid Email Format', '', '', 'Client');
+
+ return false;
+ }
+
+ function client(&$data)
+ {
+ $attachments = array();
+
+ /* If neither matches, we'll just try it anyway. */
+ if (stristr($data, 'Content-Type: application/dime')) {
+ $this->_decodeDIMEMessage($data, $this->headers, $attachments);
+ } elseif (stristr($data, 'MIME-Version:')) {
+ /* This is a mime message, let's decode it. */
+ $this->_decodeMimeMessage($data, $this->headers, $attachments);
+ } else {
+ /* The old fallback, but decodeMimeMessage handles things fine. */
+ $this->_parseEmail($data);
+ }
+
+ /* Get the character encoding of the incoming request treat incoming
+ * data as UTF-8 if no encoding set. */
+ if (!$this->soapfault &&
+ !$this->_getContentEncoding($this->headers['content-type'])) {
+ $this->xml_encoding = SOAP_DEFAULT_ENCODING;
+ /* An 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->soapfault) {
+ return $this->soapfault->getFault();
+ }
+
+ $client =& new SOAP_Client(null);
+
+ return $client->parseResponse($data, $this->xml_encoding, $this->attachments);
+ }
+
+ function service(&$data, $endpoint = '', $send_response = true,
+ $dump = false)
+ {
+ $this->endpoint = $endpoint;
+ $attachments = array();
+ $headers = array();
+
+ /* If neither matches, we'll just try it anyway. */
+ if (stristr($data, 'Content-Type: application/dime')) {
+ $this->_decodeDIMEMessage($data, $this->headers, $attachments);
+ $useEncoding = 'DIME';
+ } elseif (stristr($data, 'MIME-Version:')) {
+ /* This is a mime message, let's decode it. */
+ $this->_decodeMimeMessage($data, $this->headers, $attachments);
+ $useEncoding = 'Mime';
+ } else {
+ /* The old fallback, but decodeMimeMessage handles things fine. */
+ $this->_parseEmail($data);
+ }
+
+ /* Get the character encoding of the incoming request treat incoming
+ * data as UTF-8 if no encoding set. */
+ if (!$this->_getContentEncoding($this->headers['content-type'])) {
+ $this->xml_encoding = SOAP_DEFAULT_ENCODING;
+ /* An encoding we don't understand, return a fault. */
+ $this->_raiseSoapFault('Unsupported encoding, use one of ISO-8859-1, US-ASCII, UTF-8', '', '', 'Server');
+ $response = $this->getFaultMessage();
+ }
+
+ if ($this->soapfault) {
+ $response = $this->soapfault->message();
+ } else {
+ $soap_msg = $this->parseRequest($data,$attachments);
+
+ /* Handle Mime or DIME encoding. */
+ /* TODO: DIME Encoding 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);
+ $soap_msg['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'])) {
+ $headers = $soap_msg['headers'];
+ }
+ } else {
+ $response = $soap_msg;
+ }
+ }
+
+ if ($this->send_response) {
+ if ($dump) {
+ print $response;
+ } else {
+ $from = array_key_exists('reply-to', $this->headers) ? $this->headers['reply-to'] : $this->headers['from'];
+
+ $soap_transport =& SOAP_Transport::getTransport('mailto:' . $from, $this->response_encoding);
+ $from = $this->endpoint ? $this->endpoint : $this->headers['to'];
+ $headers['In-Reply-To'] = $this->headers['message-id'];
+ $options = array('from' => $from, 'subject' => $this->headers['subject'], 'headers' => $headers);
+ $soap_transport->send($response, $options);
+ }
+ }
+ }
+}
Index: branches/feature-module-update/data/module/SOAP/Server/Email_Gateway.php
===================================================================
--- branches/feature-module-update/data/module/SOAP/Server/Email_Gateway.php (revision 16957)
+++ branches/feature-module-update/data/module/SOAP/Server/Email_Gateway.php (revision 16957)
@@ -0,0 +1,138 @@
+ Port to PEAR and more
+ * @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/Server/Email.php';
+require_once 'SOAP/Transport.php';
+
+/**
+ * SOAP Server Class that implements an email SOAP server.
+ * http://www.pocketsoap.com/specs/smtpbinding/
+ *
+ * This class overrides the default HTTP server, providing the ability to
+ * parse an email message and execute soap calls. This class DOES NOT pop the
+ * message; the message, complete with headers, must be passed in as a
+ * parameter to the service function call.
+ *
+ * This class calls a provided HTTP SOAP server, forwarding the email request,
+ * then sending the HTTP response out as an email.
+ *
+ * @access public
+ * @package SOAP
+ * @author Shane Caraveo
+ */
+class SOAP_Server_Email_Gateway extends SOAP_Server_Email {
+
+ var $gateway = null;
+ var $dump = false;
+
+ function SOAP_Server_Email_Gateway($gateway = '', $send_response = true,
+ $dump = false)
+ {
+ parent::SOAP_Server();
+ $this->send_response = $send_response;
+ $this->gateway = $gateway;
+ $this->dump = $dump;
+ }
+
+ function service(&$data, $gateway = '', $endpoint = '',
+ $send_response = true, $dump = false)
+ {
+ $this->endpoint = $endpoint;
+ $response = '';
+ $useEncoding = 'Mime';
+ $options = array();
+ if (!$gateway) {
+ $gateway = $this->gateway;
+ }
+
+ /* We have a full set of headers, need to find the first blank
+ * line. */
+ $this->_parseEmail($data);
+ if ($this->fault) {
+ $response = $this->fault->message();
+ }
+ if ($this->headers['content-type'] == 'application/dime')
+ $useEncoding = 'DIME';
+
+ /* Call the HTTP Server. */
+ if (!$response) {
+ $soap_transport =& SOAP_Transport::getTransport($gateway, $this->xml_encoding);
+ if ($soap_transport->fault) {
+ $response = $soap_transport->fault->message();
+ }
+ }
+
+ /* Send the message. */
+ if (!$response) {
+ $options['soapaction'] = $this->headers['soapaction'];
+ $options['headers']['Content-Type'] = $this->headers['content-type'];
+
+ $response = $soap_transport->send($data, $options);
+ if (isset($this->headers['mime-version']))
+ $options['headers']['MIME-Version'] = $this->headers['mime-version'];
+
+ if ($soap_transport->fault) {
+ $response = $soap_transport->fault->message();
+ } else {
+ foreach ($soap_transport->transport->attachments as $cid => $body) {
+ $this->attachments[] = array('body' => $body, 'cid' => $cid, 'encoding' => 'base64');
+ }
+ if (count($this->_attachments)) {
+ if ($useEncoding == 'Mime') {
+ $soap_msg = $this->_makeMimeMessage($response);
+ $options['headers']['MIME-Version'] = '1.0';
+ } else {
+ /* Default is DIME. */
+ $soap_msg = $this->_makeDIMEMessage($response);
+ $options['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'])) {
+ if (isset($options['headers'])) {
+ $options['headers'] = array_merge($options['headers'], $soap_msg['headers']);
+ } else {
+ $options['headers'] = $soap_msg['headers'];
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if ($this->send_response) {
+ if ($this->dump || $dump) {
+ print $response;
+ } else {
+ $from = array_key_exists('reply-to', $this->headers) ? $this->headers['reply-to'] : $this->headers['from'];
+
+ $soap_transport =& SOAP_Transport::getTransport('mailto:' . $from, $this->response_encoding);
+ $from = $this->endpoint ? $this->endpoint : $this->headers['to'];
+ $headers = array('In-Reply-To' => $this->headers['message-id']);
+ $options = array('from' => $from, 'subject'=> $this->headers['subject'], 'headers' => $headers);
+ $soap_transport->send($response, $options);
+ }
+ }
+ }
+}
Index: branches/feature-module-update/data/module/SOAP/Disco.php
===================================================================
--- branches/feature-module-update/data/module/SOAP/Disco.php (revision 16957)
+++ branches/feature-module-update/data/module/SOAP/Disco.php (revision 16957)
@@ -0,0 +1,383 @@
+
+ * @author Chuck Hagenbuch
+ * @author Jan Schneider
+ * @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';
+
+class SOAP_DISCO_Server extends SOAP_Base_Object {
+
+ var $namespaces = array(SCHEMA_WSDL => 'wsdl', SCHEMA_SOAP => 'soap');
+ var $import_ns = array();
+ var $wsdl = '';
+ var $disco = '';
+ var $_wsdl = array();
+ var $_disco = array();
+ var $_service_name = '';
+ var $_service_ns = '';
+ var $_service_desc = '';
+ var $_portname = '';
+ var $_bindingname = '';
+ var $soap_server = NULL;
+
+
+ function SOAP_DISCO_Server($soap_server, $service_name, $service_desc = '',
+ $import_ns = null)
+ {
+ parent::SOAP_Base_Object('Server');
+
+ if ( !is_object($soap_server)
+ || !get_class($soap_server) == 'soap_server') return;
+
+ $this->_service_name = $service_name;
+ $this->_service_ns = "urn:$service_name";
+ $this->_service_desc = $service_desc;
+ $this->import_ns = isset($import_ns) ? $import_ns : $this->import_ns;
+ $this->soap_server = $soap_server;
+ $this->host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : 'localhost';
+ }
+
+ function getDISCO()
+ {
+ $this->_generate_DISCO();
+ return $this->disco;
+ }
+
+ function getWSDL()
+ {
+ $this->_generate_WSDL();
+ return $this->wsdl;
+ }
+
+ function _generate_DISCO()
+ {
+ // DISCO
+ $this->_disco['disco:discovery']['attr']['xmlns:disco'] = SCHEMA_DISCO;
+ $this->_disco['disco:discovery']['attr']['xmlns:scl'] = SCHEMA_DISCO_SCL;
+ $this->_disco['disco:discovery']['scl:contractRef']['attr']['ref'] =
+ (array_key_exists('HTTPS', $_SERVER) && $_SERVER['HTTPS'] == 'on')
+ ? 'https://' . $this->host . $_SERVER['PHP_SELF'] . '?wsdl'
+ : 'http://' . $this->host . $_SERVER['PHP_SELF'] . '?wsdl';
+
+ // generate disco xml
+ $this->_generate_DISCO_XML($this->_disco);
+ }
+
+ function _generate_WSDL()
+ {
+ // WSDL
+ if (is_array($this->soap_server->_namespaces)) {
+ // need to get: typens, xsd & SOAP-ENC
+ $flipped = array_flip($this->soap_server->_namespaces);
+ $this->namespaces[$this->_service_ns] = 'tns';
+ $this->namespaces[$flipped['xsd']] = 'xsd';
+ $this->namespaces[$flipped['SOAP-ENC']] = 'SOAP-ENC';
+ }
+
+ // DEFINITIONS
+ $this->_wsdl['definitions']['attr']['name'] = $this->_service_name;
+ $this->_wsdl['definitions']['attr']['targetNamespace'] = $this->_service_ns;
+ foreach ($this->namespaces as $ns => $prefix) {
+ $this->_wsdl['definitions']['attr']['xmlns:' . $prefix] = $ns;
+ }
+ $this->_wsdl['definitions']['attr']['xmlns'] = SCHEMA_WSDL;
+
+ // Import namespaces. Seems to not work yet: wsdl.exe fom .NET can't
+ // handle imported complete wsdl-definitions.
+ if (count($this->import_ns)) {
+ $i = 0;
+ foreach ($this->import_ns as $_ns => $_location) {
+ $this->_wsdl['definitions']['import'][$i]['attr']['location'] = $_location;
+ $this->_wsdl['definitions']['import'][$i]['attr']['namespace'] = $_ns;
+ $i++;
+ }
+ }
+ $this->_wsdl['definitions']['types']['attr']['xmlns']='http://schemas.xmlsoap.org/wsdl/';
+ $this->_wsdl['definitions']['types']['schema']=array();
+
+ // Placeholder for messages
+ $this->_wsdl['definitions']['message'] = array();
+
+ // PORTTYPE-NAME
+ $this->_portname = $this->_service_name . 'Port';
+ $this->_wsdl['definitions']['portType']['attr']['name'] = $this->_portname;
+
+ // BINDING-NAME
+ $this->_bindingname = $this->_service_name . 'Binding';
+ $this->_wsdl['definitions']['binding']['attr']['name'] = $this->_bindingname;
+ $this->_wsdl['definitions']['binding']['attr']['type'] = 'tns:' . $this->_portname;
+ $this->_wsdl['definitions']['binding']['soap:binding']['attr']['style'] = 'rpc';
+ $this->_wsdl['definitions']['binding']['soap:binding']['attr']['transport'] = SCHEMA_SOAP_HTTP;
+
+ // SERVICE
+ $this->_wsdl['definitions']['service']['attr']['name'] = $this->_service_name . 'Service';
+ $this->_wsdl['definitions']['service']['documentation']['attr'] = '';
+ $this->_wsdl['definitions']['service']['documentation'] = htmlentities($this->_service_desc);
+ $this->_wsdl['definitions']['service']['port']['attr']['name'] = $this->_portname;
+ $this->_wsdl['definitions']['service']['port']['attr']['binding'] = 'tns:' . $this->_bindingname;
+ $this->_wsdl['definitions']['service']['port']['soap:address']['attr']['location'] =
+ (array_key_exists('HTTPS', $_SERVER) && $_SERVER['HTTPS'] == 'on')
+ ? 'https://' . $this->host . $_SERVER['PHP_SELF']
+ : 'http://' . $this->host . $_SERVER['PHP_SELF'];
+
+ //
+ $dispatch_keys = array_keys($this->soap_server->dispatch_objects);
+ $dc = count($dispatch_keys);
+ for ($di = 0; $di < $dc; $di++) {
+ $namespace = $dispatch_keys[$di];
+ $namespace_objects =& $this->soap_server->dispatch_objects[$namespace];
+ $oc = count($namespace_objects);
+ for ($oi = 0; $oi < $oc; $oi++) {
+ $object = $namespace_objects[$oi];
+ // types definitions
+ $this->addSchemaFromMap($object->__typedef);
+ // MESSAGES
+ $this->addMethodsFromMap($object->__dispatch_map, $namespace, get_class($object));
+ }
+ }
+ if (isset($this->soap_server->dispatch_map)) {
+ $this->addMethodsFromMap($this->soap_server->dispatch_map, $namespace);
+ }
+
+ // generate wsdl
+ $this->_generate_WSDL_XML();
+ }
+
+ function &_getSchema($namespace)
+ {
+ // SCHEMA
+ $c = count($this->_wsdl['definitions']['types']['schema']);
+ for($i = 0; $i < $c; $i++) {
+ if ($this->_wsdl['definitions']['types']['schema'][$i]['attr']['targetNamespace'] == $namespace) {
+ return $this->_wsdl['definitions']['types']['schema'][$i];
+ }
+ }
+
+ // don't have this namespace
+ $schema = array();
+ $schema['attr'] = array();
+ $schema['complexType'] = array();
+ $schema['attr']['xmlns'] = array_search('xsd',$this->namespaces);
+ $schema['attr']['targetNamespace'] = $namespace;
+ $this->_wsdl['definitions']['types']['schema'][] =& $schema;
+
+ return $schema;
+ }
+
+ function addSchemaFromMap(&$map)
+ {
+ if (!$map) {
+ return;
+ }
+
+ foreach ($map as $_type_name => $_type_def) {
+ list($typens,$type) = $this->_getTypeNs($_type_name);
+ if ($typens == 'xsd') {
+ // cannot add to xsd, lets use method_namespace
+ $typens = 'tns';
+ }
+ $schema =& $this->_getSchema(array_search($typens, $this->namespaces));
+ if (!$this->_ifComplexTypeExists($schema['complexType'], $type)) {
+ $ctype =& $schema['complexType'][];
+ $ctype['attr']['name'] = $type;
+ foreach ($_type_def as $_varname => $_vartype) {
+ if (!is_int($_varname)) {
+ list($_vartypens,$_vartype) = $this->_getTypeNs($_vartype);
+ $ctype['all']['attr'] = '';
+ $el =& $ctype['all']['element'][];
+ $el['attr']['name'] = $_varname;
+ $el['attr']['type'] = $_vartypens . ':' . $_vartype;
+ } else {
+ $ctype['complexContent']['attr'] = '';
+ $ctype['complexContent']['restriction']['attr']['base'] = 'SOAP-ENC:Array';
+ foreach ($_vartype as $array_type) {
+ list($_vartypens, $_vartype) = $this->_getTypeNs($array_type);
+ $ctype['complexContent']['restriction']['attribute']['attr']['ref'] = 'SOAP-ENC:arrayType';
+ $ctype['complexContent']['restriction']['attribute']['attr']['wsdl:arrayType'] = $_vartypens . ':' . $_vartype . '[]';
+ }
+ }
+ }
+ }
+ }
+ }
+
+ function addMethodsFromMap(&$map, $namespace, $classname = null)
+ {
+ if (!$map) {
+ return;
+ }
+
+ foreach ($map as $method_name => $method_types) {
+ if (array_key_exists('namespace', $method_types)) {
+ $method_namespace = $method_types['namespace'];
+ } else {
+ $method_namespace = $namespace;
+ }
+
+ // INPUT
+ $input_message = array('attr' => array('name' => $method_name . 'Request'));
+ if (isset($method_types['in']) && is_array($method_types['in'])) {
+ foreach ($method_types['in'] as $name => $type) {
+ list($typens, $type) = $this->_getTypeNs($type);
+ $part = array();
+ $part['attr']['name'] = $name;
+ $part['attr']['type'] = $typens . ':' . $type;
+ $input_message['part'][] = $part;
+ }
+ }
+ $this->_wsdl['definitions']['message'][] = $input_message;
+
+ // OUTPUT
+ $output_message = array('attr' => array('name' => $method_name . 'Response'));
+ if (isset($method_types['out']) && is_array($method_types['out'])) {
+ foreach ($method_types['out'] as $name => $type) {
+ list($typens, $type) = $this->_getTypeNs($type);
+ $part = array();
+ $part['attr']['name'] = $name;
+ $part['attr']['type'] = $typens . ':' . $type;
+ $output_message['part'][] = $part;
+ }
+ }
+ $this->_wsdl['definitions']['message'][] = $output_message;
+
+ // PORTTYPES
+ $operation = array();
+ $operation['attr']['name'] = $method_name;
+ // INPUT
+ $operation['input']['attr']['message'] = 'tns:' . $input_message['attr']['name'];
+ // OUTPUT
+ $operation['output']['attr']['message'] = 'tns:' . $output_message['attr']['name'];
+ $this->_wsdl['definitions']['portType']['operation'][] = $operation;
+
+ // BINDING
+ $binding = array();
+ $binding['attr']['name'] = $method_name;
+ $action = $method_namespace . '#' . ($classname ? $classname . '#' : '') . $method_name;
+ $binding['soap:operation']['attr']['soapAction'] = $action;
+ // INPUT
+ $binding['input']['attr'] = '';
+ $binding['input']['soap:body']['attr']['use'] = 'encoded';
+ $binding['input']['soap:body']['attr']['namespace'] = $method_namespace;
+ $binding['input']['soap:body']['attr']['encodingStyle'] = SOAP_SCHEMA_ENCODING;
+ // OUTPUT
+ $binding['output']['attr'] = '';
+ $binding['output']['soap:body']['attr']['use'] = 'encoded';
+ $binding['output']['soap:body']['attr']['namespace'] = $method_namespace;
+ $binding['output']['soap:body']['attr']['encodingStyle'] = SOAP_SCHEMA_ENCODING;
+ $this->_wsdl['definitions']['binding']['operation'][] = $binding;
+ }
+ }
+
+ function _generate_DISCO_XML($disco_array)
+ {
+ $disco = '';
+ foreach ($disco_array as $key => $val) {
+ $disco .= $this->_arrayToNode($key,$val);
+ }
+ $this->disco = $disco;
+ }
+
+ function _generate_WSDL_XML()
+ {
+ $wsdl = '';
+ foreach ($this->_wsdl as $key => $val) {
+ $wsdl .= $this->_arrayToNode($key, $val);
+ }
+ $this->wsdl = $wsdl;
+ }
+
+ function _arrayToNode($node_name = '', $array)
+ {
+ $return = '';
+ if (is_array($array)) {
+ // we have a node if there's key 'attr'
+ if (array_key_exists('attr',$array)) {
+ $return .= "<$node_name";
+ if (is_array($array['attr'])) {
+ foreach ($array['attr'] as $attr_name => $attr_value) {
+ $return .= " $attr_name=\"$attr_value\"";
+ }
+ }
+
+ // unset 'attr' and proceed other childs...
+ unset($array['attr']);
+
+ if (count($array) > 0) {
+ $i = 0;
+ foreach ($array as $child_node_name => $child_node_value) {
+ $return .= $i == 0 ? ">\n" : '';
+ $return .= $this->_arrayToNode($child_node_name,$child_node_value);
+ $i++;
+ }
+ $return .= "\n";
+ } else {
+ $return .= " />\n";
+ }
+ } else {
+ // we have no 'attr' key in array - so it's list of nodes with
+ // the same name ...
+ foreach ($array as $child_node_name => $child_node_value) {
+ $return .= $this->_arrayToNode($node_name,$child_node_value);
+ }
+ }
+ } else {
+ // $array is not an array
+ if ($array !='') {
+ // and its not empty
+ $return .= "<$node_name>$array\n";
+ } else {
+ // and its empty...
+ $return .= "<$node_name />\n";
+ }
+ }
+ return $return;
+ }
+
+ function _getTypeNs($type)
+ {
+ preg_match_all("'\{(.*)\}'sm", $type, $m);
+ if (isset($m[1][0]) && $m[1][0] != '') {
+ if (!array_key_exists($m[1][0],$this->namespaces)) {
+ $ns_pref = 'ns' . count($this->namespaces);
+ $this->namespaces[$m[1][0]] = $ns_pref;
+ $this->_wsdl['definitions']['attr']['xmlns:' . $ns_pref] = $m[1][0];
+ }
+ $typens = $this->namespaces[$m[1][0]];
+ $type = ereg_replace($m[0][0],'',$type);
+ } else {
+ $typens = 'xsd';
+ }
+ return array($typens,$type);
+ }
+
+ function _ifComplexTypeExists($typesArray, $type_name)
+ {
+ if (is_array($typesArray)) {
+ foreach ($typesArray as $type_data) {
+ if ($type_data['attr']['name'] == $type_name) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+}