/** * SOAP_Transport_SMTP Constructor * * @param string $url mailto: address. * * @access public */ function SOAP_Transport_SMTP($url, $encoding = 'US-ASCII') { parent::SOAP_Base('SMTP'); $this->encoding = $encoding; $this->urlparts = @parse_url($url); $this->url = $url; }
/** * SOAP_Transport_HTTP Constructor * * @access public * * @param string $url HTTP url to SOAP endpoint. * @param string $encoding Encoding to use. */ function SOAP_Transport_HTTP($url, $encoding = SOAP_DEFAULT_ENCODING) { parent::SOAP_Base('HTTP'); $this->urlparts = @parse_url($url); $this->url = $url; $this->encoding = $encoding; }
/** * SOAP_Client::call * * 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. * * @param string method * @param array params * @param array options (hash with namespace, soapaction, timeout, from, subject, etc.) * * The options parameter can have a variety of values added. The currently supported * values are: * namespace * soapaction * timeout (http socket timeout) * from (smtp) * transfer-encoding (smtp, sets the Content-Transfer-Encoding header) * subject (smtp, subject header) * headers (smtp, array-hash of extra smtp headers) * * @return array of results * @access public */ 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)) { return $this->_raiseSoapFault($soap_data); } // __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, // though 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; return $this->_raiseSoapFault($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'] > 0) { $this->__last_request =& $this->_soap_transport->outgoing_payload; $this->__last_response =& $this->_soap_transport->incoming_payload; $this->wire =& $this->__get_wire(); } if ($this->_soap_transport->fault) { return $this->_raiseSoapFault($this->xml); } $this->__attachments =& $this->_soap_transport->attachments; $this->__result_encoding = $this->_soap_transport->result_encoding; if (isset($this->__options['result']) && $this->__options['result'] != 'parse') { return $this->xml; } return $this->__parse($this->xml, $this->__result_encoding, $this->__attachments); }
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); } } }
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); } } }
/** * SOAP_Client::call * * @param string method * @param array params * @param string namespace (not required if using wsdl) * @param string soapAction (not required if using wsdl) * * @return array of results * @access public */ function call($method, $params = array(), $namespace = false, $soapAction = false) { $this->fault = null; if ($this->endpointType == 'wsdl') { $this->setSchemaVersion($this->wsdl->xsd); // get portName if (!$this->portName) { $this->portName = $this->wsdl->getPortName($method); if (PEAR::isError($this->portName)) { return $this->raiseSoapFault($this->portName); } } $namespace = $this->wsdl->getNamespace($this->portName, $method); // get endpoint $this->endpoint = $this->wsdl->getEndpoint($this->portName); if (PEAR::isError($this->endpoint)) { return $this->raiseSoapFault($this->endpoint); } $this->debug("endpoint: {$this->endpoint}"); $this->debug("portName: {$this->portName}"); // get operation data $opData = $this->wsdl->getOperationData($this->portName, $method); if (PEAR::isError($opData)) { return $this->raiseSoapFault($opData); } $soapAction = $opData['soapAction']; // set input params $nparams = array(); if (count($opData['input']['parts']) > 0) { $i = 0; reset($params); foreach ($opData['input']['parts'] as $name => $type) { if (isset($params[$name])) { $nparams[$name] = $params[$name]; } else { // XXX assuming it's an array, not a hash // XXX this is pretty pethetic, but "fixes" a problem where // paremeter names do not match correctly $nparams[$name] = current($params); next($params); } if (gettype($nparams[$name]) != 'object' && get_class($nparams[$name]) != 'soap_value') { // type is a qname likely, split it apart, and get the type namespace from wsdl $qname = new QName($type); if ($qname->ns) { $type_namespace = $this->wsdl->namespaces[$qname->ns]; } else { $type_namespace = NULL; } $type = $qname->name; $nparams[$name] = new SOAP_Value($name, $type, $nparams[$name], $namespace, $type_namespace, $this->wsdl); } } } $params = $nparams; } $this->debug("soapAction: {$soapAction}"); $this->debug("namespace: {$namespace}"); // make message $soapmsg = new SOAP_Message($method, $params, $namespace, NULL, $this->wsdl); if ($soapmsg->fault) { return $this->raiseSoapFault($soapmsg->fault); } // serialize the message $soap_data = $soapmsg->serialize(); $this->debug("soap_data " . $soap_data); if (PEAR::isError($soap_data)) { return $this->raiseSoapFault($soap_data); } $this->debug('<xmp>' . $soap_data . '</xmp>'); // instantiate client $dbg = "calling server at '{$this->endpoint}'..."; $soap_transport = new SOAP_Transport($this->endpoint, $this->debug_flag); if ($soap_transport->fault) { return $this->raiseSoapFault($soap_transport->fault); } $this->debug($dbg . 'instantiated client successfully'); $this->debug("endpoint: {$this->endpoint}<br>\n"); // send $dbg = "sending msg w/ soapaction '{$soapAction}'..."; // send the message $this->response = $soap_transport->send($soap_data, $soapAction); if ($soap_transport->fault) { return $this->raiseSoapFault($this->response); } // parse the response $return = $soapmsg->parseResponse($this->response); $this->debug($soap_transport->debug_data); $this->debug($dbg . 'sent message successfully and got a(n) ' . gettype($return) . ' back'); // check for valid response if (PEAR::isError($return)) { return $this->raiseSoapFault($return); } else { if (strcasecmp(get_class($return), 'SOAP_Value') != 0) { return $this->raiseSoapFault("didn't get SOAP_Value object back from client"); } } // decode to native php datatype $returnArray = $return->decode(); // fault? if (PEAR::isError($returnArray)) { return $this->raiseSoapFault($returnArray); } if (is_array($returnArray)) { if (isset($returnArray['faultcode']) || isset($returnArray['SOAP-ENV:faultcode'])) { foreach ($returnArray as $k => $v) { if (stristr($k, 'faultcode')) { $this->faultcode = $v; } if (stristr($k, 'faultstring')) { $this->faultstring = $v; } if (stristr($k, 'faultdetail')) { $this->faultdetail = $v; } if (stristr($k, 'faultactor')) { $this->faultactor = $v; } } return $this->raiseSoapFault($this->faultstring, $this->faultdetail, $this->faultactor, $this->faultcode); } // return array of return values if (count($returnArray) == 1) { return array_shift($returnArray); } return $returnArray; } return $returnArray; }
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'; } else { if (stristr($data, 'MIME-Version:')) { // this is a mime message, lets decode it. #$data = 'Content-Type: '.stripslashes($_SERVER['CONTENT_TYPE'])."\r\n\r\n".$data; $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 (!$response && !$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 // XXX 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); $header['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']; # XXX what if no 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); } } }
/** * 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:<pre> * 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) * </pre> * * @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); /* echo "<pre>"; print_r($soap_data); exit; */ /* xdebug_break(); file_put_contents('/var/www/html/test_files/soap.txt', $soap_data); echo "<pre>"; echo htmlentities($soap_data); //print_r($soap_data); exit; */ //file_put_contents('/var/www/html/ddservice/data/soap_templiga_allkiri_htmlescaped.ddoc.txt', $soap_data); $this->xml = $this->_soap_transport->send($soap_data, $transport_options); // Save the wire information for debugging. if ($this->__options['trace'] > 0) { $this->__last_request =& $this->_soap_transport->outgoing_payload; $this->__last_response =& $this->_soap_transport->incoming_payload; $this->wire = $this->__get_wire(); } if ($this->_soap_transport->fault) { $fault =& $this->_raiseSoapFault($this->xml); return $fault; } $this->__attachments =& $this->_soap_transport->attachments; $this->__result_encoding = $this->_soap_transport->result_encoding; if (isset($this->__options['result']) && $this->__options['result'] != 'parse') { return $this->xml; } $result =& $this->__parse($this->xml, $this->__result_encoding, $this->__attachments); return $result; }