/**
  * 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 transport, Content-Transfer-Encoding: header
  * - 'from': SMTP transport, From: header
  * - 'subject': SMTP transport, Subject: header
  * - 'headers': SMTP transport, hash of extra SMTP headers
  * - 'attachments': what encoding to use for attachments (Mime, Dime)
  * - 'trace': whether to trace the SOAP communication
  * - 'style': 'document' or 'rpc'; when set to 'document' the parameters
  *   are not wrapped inside a tag with the SOAP action name
  * - 'use': 'literal' for literal encoding, anything else for section 5
  *   encoding; when set to 'literal' SOAP types will be omitted.
  * - 'keep_arrays_flat': use the tag name multiple times for each element
  *   when passing in an array in literal mode
  * - 'no_type_prefix': supress adding of the namespace prefix
  *
  * @access public
  *
  * @param string $method           The method to call.
  * @param array $params            The method parameters.
  * @param string|array $namespace  Namespace or hash with options. Note:
  *                                 most options need to be repeated for
  *                                 SOAP_Value instances.
  * @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->_raiseSoapFault($this->_soap_transport);
             $this->_soap_transport = null;
             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;
 }
示例#2
0
 /**
  * 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;
 }