| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * @author Samisa Abeysinghe (sabeysinghe@virtusa.com) |
| * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com) |
| */ |
| |
| // !!! This include file must be first thing in file !!! |
| #include "../../platforms/PlatformAutoSense.hpp" |
| |
| #include <stdio.h> |
| |
| #include <axis/AxisWrapperAPI.hpp> |
| #include <axis/UnknownElementException.hpp> |
| #include <axis/client/Stub.hpp> |
| #include <axis/IAttribute.hpp> |
| |
| #include "../../transport/SOAPTransport.h" |
| #include "../../soap/SoapSerializer.h" |
| #include "../../common/AxisUtils.h" |
| #include "../../common/AxisConfig.h" |
| #include "../../common/AxisGenException.h" |
| #include "../../soap/Attribute.h" |
| |
| #include "../../common/AxisTrace.h" |
| |
| extern AXIS_CPP_NAMESPACE_PREFIX AxisConfig* g_pConfig; |
| |
| AXIS_CPP_NAMESPACE_USE |
| |
| Stub::Stub (const char *pcEndPointUri, AXIS_PROTOCOL_TYPE eProtocol): |
| m_proxyUsername (NULL), |
| m_proxyPassword (NULL), |
| m_pExceptionHandler(NULL) |
| { |
| m_pCall = new Call (); |
| |
| // Weird, yes, but need to do here since tracing is not enabled until after instantiation of Call class. |
| logEntryEngine("Stub::Stub") |
| |
| m_pCall->setProtocol (eProtocol); |
| m_pTransport = m_pCall->getTransport (); |
| m_pTransport->setEndpointUri( pcEndPointUri); |
| m_viCurrentSOAPHeaderBlock = m_vSOAPHeaderBlocks.end(); |
| |
| // SSL channel related initilizations |
| char * pcSSLChannelInfo = g_pConfig->getAxisConfProperty( AXCONF_SECUREINFO); |
| if( pcSSLChannelInfo && strlen( pcSSLChannelInfo) > 0) |
| { |
| char * pszArgPtr = NULL; |
| int iArgIndex = 0; |
| |
| pszArgPtr = strtok( pcSSLChannelInfo, ","); |
| |
| while( pszArgPtr != NULL && iArgIndex < 8) |
| { |
| m_sArguments[iArgIndex] = pszArgPtr; |
| iArgIndex++; |
| pszArgPtr = strtok( NULL, ","); |
| while( pszArgPtr != NULL && *pszArgPtr == ' ' && *pszArgPtr != '\0') |
| pszArgPtr++; |
| } |
| } |
| |
| logExit() |
| } |
| |
| Stub::~Stub () |
| { |
| logEntryEngine("Stub::~Stub") |
| |
| delete m_pCall; |
| m_pCall = NULL; |
| |
| unsigned int j = 0; |
| for (j = 0; j < m_vSOAPHeaderBlocks.size (); j++) |
| { |
| delete m_vSOAPHeaderBlocks[j]; |
| m_vSOAPHeaderBlocks[j] = NULL; |
| } |
| |
| logExit() |
| } |
| |
| void |
| Stub::setEndPoint (const char *pcEndPoint) |
| { |
| logEntryEngine("Stub::setEndPoint") |
| |
| if (m_pTransport) |
| m_pTransport->setEndpointUri( pcEndPoint); |
| |
| logExit() |
| } |
| |
| void |
| Stub::setTransportProperty (const char *pcKey, const char *pcValue) |
| { |
| logEntryEngine("Stub::setTransportProperty") |
| |
| if (m_pTransport) |
| { |
| if(!pcKey) |
| { |
| m_pTransport=NULL; //this should be set to null. otherwise the previous setting can be still there. |
| } |
| else if (strcmp (pcKey, "SOAPAction") == 0) |
| { |
| // both "" missing |
| if (pcValue |
| && (pcValue[0] != '"' |
| && pcValue[strlen (pcValue) - 1] != '"')) |
| { |
| char *tempvalue = new char[strlen (pcValue) + 3]; |
| sprintf (tempvalue, "\"%s\"", pcValue); |
| m_pTransport->setTransportProperty (pcKey, tempvalue); |
| delete[]tempvalue; |
| } |
| else if (pcValue && (pcValue[0] != '"')) //starting '"' missing |
| { |
| char *tempvalue = new char[strlen (pcValue) + 2]; |
| sprintf (tempvalue, "\"%s", pcValue); |
| m_pTransport->setTransportProperty (pcKey, tempvalue); |
| delete[]tempvalue; |
| } |
| else if (pcValue && (pcValue[strlen (pcValue) - 1] != '"')) // ending '"' missing |
| { |
| char *tempvalue = new char[strlen (pcValue) + 3]; |
| sprintf (tempvalue, "\"%s\"", pcValue); |
| m_pTransport->setTransportProperty (pcKey, tempvalue); |
| delete[]tempvalue; |
| } |
| else // both "" present |
| m_pTransport->setTransportProperty (pcKey, pcValue); |
| } |
| else |
| m_pTransport->setTransportProperty (pcKey, pcValue); |
| } |
| |
| logExit() |
| } |
| |
| const char * |
| Stub::getTransportProperty (const char *key, bool response) |
| { |
| return m_pCall->getTransportProperty (key, response); |
| } |
| |
| const char * |
| Stub::getFirstTransportPropertyKey (bool response) |
| { |
| if (m_pTransport) |
| return m_pTransport->getFirstTransportPropertyKey (response); |
| |
| return NULL; |
| } |
| |
| const char * |
| Stub::getNextTransportPropertyKey (bool response) |
| { |
| if (m_pTransport) |
| return m_pTransport->getNextTransportPropertyKey (response); |
| |
| return NULL; |
| } |
| |
| const char * |
| Stub::getCurrentTransportPropertyKey (bool response) |
| { |
| if (m_pTransport) |
| return m_pTransport->getCurrentTransportPropertyKey (response); |
| |
| return NULL; |
| } |
| |
| const char * |
| Stub::getCurrentTransportPropertyValue (bool response) |
| { |
| if (m_pTransport) |
| return m_pTransport->getCurrentTransportPropertyValue (response); |
| |
| return NULL; |
| } |
| |
| void |
| Stub::deleteCurrentTransportProperty (bool response) |
| { |
| if (m_pTransport) |
| m_pTransport->deleteCurrentTransportProperty (response); |
| } |
| |
| void |
| Stub::deleteTransportProperty (char *pcKey, unsigned int uiOccurance) |
| { |
| if (m_pTransport) |
| m_pTransport->deleteTransportProperty (pcKey, uiOccurance); |
| } |
| |
| void |
| Stub::setHandlerProperty (AxisChar * name, void *value, int len) |
| { |
| logEntryEngine("Stub::setHandlerProperty") |
| |
| m_pCall->setHandlerProperty (name, value, len); |
| |
| logExit() |
| } |
| |
| IHeaderBlock * |
| Stub::createSOAPHeaderBlock (AxisChar * pachLocalName, AxisChar * pachUri) |
| { |
| if (pachLocalName && pachUri) |
| { |
| if ((AxisUtils::isStringOnlyWithSpaces (pachLocalName)) |
| || (AxisUtils::isStringOnlyWithSpaces (pachUri))) |
| return NULL; |
| else |
| { |
| IHeaderBlock *pNewSoapheader = m_pCall->createHeaderBlock (pachLocalName, pachUri); |
| m_vSOAPHeaderBlocks.push_back (pNewSoapheader); |
| return pNewSoapheader; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| IHeaderBlock * |
| Stub::getFirstSOAPHeaderBlock () |
| { |
| m_viCurrentSOAPHeaderBlock = m_vSOAPHeaderBlocks.begin (); |
| if (m_viCurrentSOAPHeaderBlock == m_vSOAPHeaderBlocks.end ()) |
| return NULL; |
| else |
| return (*m_viCurrentSOAPHeaderBlock); |
| |
| } |
| |
| IHeaderBlock * |
| Stub::getNextSOAPHeaderBlock () |
| { |
| //already at the end? |
| if (m_viCurrentSOAPHeaderBlock == m_vSOAPHeaderBlocks.end ()) |
| return NULL; |
| |
| m_viCurrentSOAPHeaderBlock++; |
| if (m_viCurrentSOAPHeaderBlock == m_vSOAPHeaderBlocks.end ()) |
| return NULL; |
| else |
| return (*m_viCurrentSOAPHeaderBlock); |
| } |
| |
| IHeaderBlock * |
| Stub::getCurrentSOAPHeaderBlock () |
| { |
| if (m_viCurrentSOAPHeaderBlock != m_vSOAPHeaderBlocks.end ()) |
| return (*m_viCurrentSOAPHeaderBlock); |
| |
| return NULL; |
| } |
| |
| void |
| Stub::deleteCurrentSOAPHeaderBlock () |
| { |
| logEntryEngine("Stub::deleteCurrentSOAPHeaderBlock") |
| |
| if (m_viCurrentSOAPHeaderBlock != m_vSOAPHeaderBlocks.end ()) |
| { |
| delete (*m_viCurrentSOAPHeaderBlock); |
| m_vSOAPHeaderBlocks.erase (m_viCurrentSOAPHeaderBlock); |
| } |
| |
| logExit() |
| } |
| |
| void |
| Stub::deleteSOAPHeaderBlock (IHeaderBlock * pHeaderBlock) |
| { |
| logEntryEngine("Stub::deleteSOAPHeaderBlock") |
| |
| vector < IHeaderBlock * >::iterator currentSOAPHeaderBlock = |
| m_vSOAPHeaderBlocks.begin (); |
| bool bDone = false; |
| while (!bDone && currentSOAPHeaderBlock != m_vSOAPHeaderBlocks.end ()) |
| { |
| if (pHeaderBlock == *currentSOAPHeaderBlock) |
| { |
| delete (*currentSOAPHeaderBlock); |
| m_vSOAPHeaderBlocks.erase (currentSOAPHeaderBlock); |
| bDone = true; |
| } |
| currentSOAPHeaderBlock++; |
| } |
| |
| logExit() |
| } |
| |
| void |
| Stub::setSOAPHeaders () |
| { |
| logEntryEngine("Stub::setSOAPHeaders") |
| |
| SoapSerializer *pSerializer = NULL; |
| if (m_pCall) |
| pSerializer = m_pCall->getSOAPSerializer (); |
| |
| if (pSerializer) |
| for (unsigned int i = 0; i < m_vSOAPHeaderBlocks.size (); i++) |
| pSerializer->addHeaderBlock (m_vSOAPHeaderBlocks[i]); |
| |
| logExit() |
| } |
| |
| void |
| Stub::addNamespaceToSOAPHeader(const AxisChar * pUri, const AxisChar * pPrefix) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, "", pPrefix, pUri, ""); |
| |
| m_vSOAPHeaderNamespaces.push_back ((IAttribute *)pAttribute); |
| } |
| |
| |
| void |
| Stub::clearSOAPHeaderNamespaces() |
| { |
| unsigned int j = 0; |
| for (j = 0; j < m_vSOAPHeaderNamespaces.size (); j++) |
| { |
| delete m_vSOAPHeaderNamespaces[j]; |
| m_vSOAPHeaderNamespaces[j] = NULL; |
| } |
| m_vSOAPHeaderNamespaces.clear(); |
| } |
| |
| |
| void |
| Stub::addAttributeToSOAPHeader(const AxisChar * pLocalname, |
| const AxisChar * pPrefix, |
| const AxisChar * pValue) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, pLocalname, pPrefix, pValue); |
| |
| m_vSOAPHeaderAttributes.push_back ((IAttribute *)pAttribute); |
| } |
| |
| |
| void |
| Stub::clearSOAPHeaderAttributes() |
| { |
| unsigned int j = 0; |
| for (j = 0; j < m_vSOAPHeaderAttributes.size (); j++) |
| { |
| delete m_vSOAPHeaderAttributes[j]; |
| m_vSOAPHeaderAttributes[j] = NULL; |
| } |
| m_vSOAPHeaderAttributes.clear(); |
| } |
| |
| |
| void |
| Stub::addNamespaceToSOAPBody(const AxisChar * pUri, const AxisChar * pPrefix) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, "", pPrefix, pUri, ""); |
| |
| m_vSOAPBodyNamespaces.push_back ((IAttribute *)pAttribute); |
| } |
| |
| |
| void |
| Stub::clearSOAPBodyNamespaces() |
| { |
| unsigned int j = 0; |
| for (j = 0; j < m_vSOAPBodyNamespaces.size (); j++) |
| { |
| delete m_vSOAPBodyNamespaces[j]; |
| m_vSOAPBodyNamespaces[j] = NULL; |
| } |
| m_vSOAPBodyNamespaces.clear(); |
| } |
| |
| |
| void |
| Stub::addAttributeToSOAPBody(const AxisChar * pLocalname, |
| const AxisChar * pPrefix, |
| const AxisChar * pValue) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, pLocalname, pPrefix, pValue); |
| |
| m_vSOAPBodyAttributes.push_back ((IAttribute *)pAttribute); |
| } |
| |
| |
| void |
| Stub::clearSOAPBodyAttributes() |
| { |
| unsigned int j = 0; |
| for (j = 0; j < m_vSOAPBodyAttributes.size (); j++) |
| { |
| delete m_vSOAPBodyAttributes[j]; |
| m_vSOAPBodyAttributes[j] = NULL; |
| } |
| m_vSOAPBodyAttributes.clear(); |
| } |
| |
| |
| void |
| Stub::applyUserPreferences () |
| { |
| logEntryEngine("Stub::applyUserPreferences") |
| |
| setSOAPHeaders (); |
| |
| // Set SOAP body and SOAP header attributes |
| SoapSerializer *pSerializer = NULL; |
| if (m_pCall) |
| pSerializer = m_pCall->getSOAPSerializer (); |
| |
| if (pSerializer) |
| { |
| unsigned int i; |
| |
| // add user-specified namespaces to SOAP header |
| for (i = 0; i < m_vSOAPHeaderNamespaces.size (); i++) |
| pSerializer->addNamespaceToSOAPHeader(m_vSOAPHeaderNamespaces[i]->getURI(), |
| m_vSOAPHeaderNamespaces[i]->getPrefix()); |
| |
| // Add user-specified attributes to SOAP header |
| for (i = 0; i < m_vSOAPHeaderAttributes.size (); i++) |
| pSerializer->addAttributeToSOAPHeader(m_vSOAPHeaderAttributes[i]->getLocalName(), |
| m_vSOAPHeaderAttributes[i]->getPrefix(), |
| m_vSOAPHeaderAttributes[i]->getValue()); |
| |
| // add user-specified namespaces to SOAP body |
| for (i = 0; i < m_vSOAPBodyNamespaces.size (); i++) |
| pSerializer->addNamespaceToSOAPBody(m_vSOAPBodyNamespaces[i]->getURI(), |
| m_vSOAPBodyNamespaces[i]->getPrefix()); |
| |
| // Add user-specified attributes to SOAP body |
| for (i = 0; i < m_vSOAPBodyAttributes.size (); i++) |
| pSerializer->addAttributeToSOAPBody(m_vSOAPBodyAttributes[i]->getLocalName(), |
| m_vSOAPBodyAttributes[i]->getPrefix(), |
| m_vSOAPBodyAttributes[i]->getValue()); |
| } |
| |
| logExit() |
| } |
| |
| void |
| Stub::setProxy (const char *pcProxyHost, unsigned int uiProxyPort) |
| { |
| logEntryEngine("Stub::setProxy") |
| |
| if (m_pTransport) |
| m_pTransport->setProxy (pcProxyHost, uiProxyPort); |
| |
| logExit() |
| } |
| |
| void |
| Stub::setTransportTimeout (long lSeconds) |
| { |
| logEntryEngine("Stub::setTransportTimeout") |
| |
| if (m_pTransport) |
| m_pTransport->setTimeout (lSeconds); |
| |
| logExit() |
| } |
| |
| void |
| Stub::setTransportConnectTimeout (long lSeconds) |
| { |
| logEntryEngine("Stub::setTransportConnectTimeout") |
| |
| if (m_pTransport) |
| m_pTransport->setConnectTimeout (lSeconds); |
| |
| logExit() |
| } |
| |
| int |
| Stub::getStatus () |
| { |
| if (m_pCall == NULL) |
| return AXIS_SUCCESS; |
| else |
| return m_pCall->getStatus (); |
| } |
| |
| void |
| Stub::setMaintainSession (bool bSession) |
| { |
| if (m_pTransport) |
| m_pTransport->setMaintainSession (bSession); |
| } |
| |
| |
| void |
| Stub::setTransportProtocol (AXIS_PROTOCOL_TYPE eProtocol) |
| { |
| if (m_pCall) |
| m_pCall->setProtocol (eProtocol); |
| } |
| |
| AXIS_PROTOCOL_TYPE |
| Stub::getTransportProtocol () |
| { |
| if (m_pCall) |
| return m_pCall->getProtocol (); |
| |
| return APT_UNKNOWN; |
| } |
| |
| IHeaderBlock * |
| Stub::createSOAPHeaderBlock (AxisChar * pachLocalName, AxisChar * pachUri, |
| AxisChar * pachPrefix) |
| { |
| if (pachLocalName && pachUri && pachPrefix) |
| { |
| if (AxisUtils::isStringOnlyWithSpaces (pachLocalName) |
| || AxisUtils::isStringOnlyWithSpaces (pachUri)) |
| return NULL; |
| else |
| { |
| IHeaderBlock *pNewSoapheader = |
| m_pCall->createHeaderBlock (pachLocalName, pachUri, pachPrefix); |
| m_vSOAPHeaderBlocks.push_back (pNewSoapheader); |
| return pNewSoapheader; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| void |
| Stub::setUsername (const char *pcUsername) |
| { |
| if (m_pTransport) |
| m_pTransport->setUsername(pcUsername); |
| } |
| |
| void |
| Stub::setProxyUsername (const char *pcProxyUsername) |
| { |
| logEntryEngine("Stub::setProxyUsername") |
| |
| if (m_proxyUsername) |
| { |
| delete[]m_proxyUsername; |
| m_proxyUsername = NULL; |
| } |
| |
| if (pcProxyUsername) |
| { |
| m_proxyUsername = new char[strlen (pcProxyUsername) + 1]; |
| strcpy (m_proxyUsername, pcProxyUsername); |
| |
| if (m_proxyPassword) |
| setProxyAuthorizationHeader (); |
| } |
| |
| logExit() |
| } |
| |
| void |
| Stub::setPassword (const char *pcPassword) |
| { |
| if (m_pTransport) |
| m_pTransport->setPassword(pcPassword); |
| } |
| |
| void |
| Stub::setProxyPassword (const char *pcProxyPassword) |
| { |
| if (m_proxyPassword) |
| { |
| delete[]m_proxyPassword; |
| m_proxyPassword = NULL; |
| } |
| |
| if (pcProxyPassword) |
| { |
| m_proxyPassword = new char[strlen (pcProxyPassword) + 1]; |
| strcpy (m_proxyPassword, pcProxyPassword); |
| |
| if (m_proxyUsername) |
| setProxyAuthorizationHeader (); |
| } |
| } |
| |
| |
| const char * |
| Stub::getProxyUsername () |
| { |
| return m_proxyUsername; |
| } |
| |
| |
| const char * |
| Stub::getProxyPassword () |
| { |
| return m_proxyPassword; |
| } |
| |
| |
| void |
| Stub::setProxyAuthorizationHeader () |
| { |
| logEntryEngine("Stub::setProxyAuthorizationHeader") |
| |
| char* cpUsernamePassword = new char[strlen( m_proxyUsername) + strlen( m_proxyPassword ) + 2]; |
| strcpy( cpUsernamePassword, m_proxyUsername ); |
| strcat( cpUsernamePassword, ":" ); |
| strcat( cpUsernamePassword, m_proxyPassword ); |
| |
| int len = apr_base64_encode_len (strlen(cpUsernamePassword)); |
| AxisChar* base64Value = new AxisChar[len + 1]; |
| len = apr_base64_encode (base64Value, (const char*)cpUsernamePassword); |
| |
| std::string strValue = "Basic "; |
| strValue += base64Value; |
| |
| this->setTransportProperty( "Proxy-Authorization", strValue.c_str()); |
| delete [] cpUsernamePassword; |
| delete [] base64Value; |
| |
| logExit() |
| } |
| |
| ISoapAttachment* Stub::createSoapAttachment() |
| { |
| logEntryEngine("Stub::createSoapAttachment") |
| |
| return m_pCall->createSoapAttachment(); |
| |
| logExit() |
| } |
| |
| /*Methods for supporting SecureChannel*/ |
| void Stub::SetSecure( char * pszArguments, ...) |
| { |
| logEntryEngine("Stub::SetSecure") |
| |
| va_list args; |
| |
| va_start( args, pszArguments); |
| SetSecure(pszArguments, args); |
| va_end( args); |
| |
| logExit() |
| } |
| |
| /*Methods for supporting SecureChannel*/ |
| void Stub::SetSecure( char * pszArguments, va_list args) |
| { |
| logEntryEngine("Stub::SetSecure") |
| |
| int iArgIndex = 0; |
| char * pszArg = pszArguments; |
| |
| if (pszArg != NULL) |
| { |
| do |
| { |
| m_sArguments[iArgIndex] = pszArg; |
| iArgIndex++; |
| } |
| while( (pszArg = va_arg( args, char *)) != NULL && iArgIndex < 8); |
| |
| // Leave for now, but remove in future. |
| if( iArgIndex == 6) |
| m_sArguments[iArgIndex] = "false"; |
| } |
| |
| logExit() |
| } |
| |
| void Stub::includeSecure() |
| { |
| m_pCall->setTransportProperty( SECURE_PROPERTIES, (const char *) &m_sArguments); |
| } |
| |
| void |
| Stub::checkForExtraneousElements () |
| { |
| logEntryEngine("Stub::checkForExtraneousElements") |
| |
| IWrapperSoapDeSerializer *pDeSerializer = m_pCall->getSOAPDeSerializer(); |
| if (pDeSerializer && m_pTransport->isThereResponseData()) |
| { |
| const char *peekedElementName = pDeSerializer->peekNextElementName(); |
| if (0x00 != *peekedElementName) |
| { |
| logThrowExceptionWithData("UnknownElementException", peekedElementName) |
| |
| throw UnknownElementException(peekedElementName); |
| } |
| } |
| |
| logExit() |
| } |