| /* |
| * 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. |
| */ |
| |
| // !!! This include file must be first thing in file !!! |
| #include "../platforms/PlatformAutoSense.hpp" |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| |
| #include <axis/GDefine.hpp> |
| |
| #include "SoapEnvelope.h" |
| #include "SoapSerializer.h" |
| #include "HeaderBlock.h" |
| #include "SoapKeywordMapping.h" |
| #include "SoapAttachmentReference.hpp" |
| #include "AxisSoapException.h" |
| #include "../common/ArrayBean.h" |
| #include "../common/BasicTypeSerializer.h" |
| #include "../common/AxisConfig.h" |
| |
| #include "../common/AxisTrace.h" |
| |
| |
| extern AXIS_CPP_NAMESPACE_PREFIX AxisConfig* g_pConfig; |
| #define MIMEBOUNDARY "------=MIME_BOUNDARY" |
| |
| AXIS_CPP_NAMESPACE_START |
| |
| SoapSerializer:: |
| SoapSerializer() |
| { |
| logEntryEngine("SoapSerializer::SoapSerializer") |
| |
| m_pSoapEnvelope = NULL; |
| m_iSoapVersion = SOAP_VER_1_1; |
| m_pOutputStream = NULL; |
| m_pNamespace = NULL; |
| m_pContentIdSet = NULL; |
| |
| reset(); |
| |
| logExit() |
| } |
| |
| SoapSerializer:: |
| ~SoapSerializer() |
| { |
| logEntryEngine("SoapSerializer::~SoapSerializer") |
| |
| delete m_pSoapEnvelope; |
| |
| /* Cleaning the memory allocated to the SoapAttachments */ |
| map<AxisXMLString, ISoapAttachment*>::iterator itCurrAttach= m_SoapAttachments.begin(); |
| while( itCurrAttach != m_SoapAttachments.end()) |
| { |
| delete( (SoapAttachment*)((*itCurrAttach).second)); |
| itCurrAttach++; |
| } |
| m_SoapAttachments.clear(); |
| |
| list<SoapAttachmentReference*>::iterator itAttRef= m_attachmentRefs.begin(); |
| while(itAttRef != m_attachmentRefs.end()) |
| { |
| delete *itAttRef; |
| itAttRef++; |
| } |
| m_attachmentRefs.clear(); |
| |
| logExit() |
| } |
| |
| int SoapSerializer:: |
| setSoapEnvelope( SoapEnvelope * pSoapEnvelope) |
| { |
| logEntryEngine("SoapSerializer::setSoapEnvelope") |
| |
| m_pSoapEnvelope = pSoapEnvelope; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int SoapSerializer:: |
| setSoapHeader( SoapHeader * pSoapHeader) |
| { |
| logEntryEngine("SoapSerializer::setSoapHeader") |
| |
| int intStatus = AXIS_FAIL; |
| |
| if( m_pSoapEnvelope) |
| { |
| /* no need to create a SOAP Header, it already exists */ |
| if( (m_pSoapEnvelope) && (m_pSoapEnvelope->m_pSoapHeader)) |
| intStatus = AXIS_OBJECT_ALREADY_EXISTS; |
| else |
| { |
| m_pSoapEnvelope->setSoapHeader( pSoapHeader); |
| intStatus= AXIS_SUCCESS; |
| } |
| } |
| |
| logExitWithReturnCode(intStatus) |
| |
| return intStatus; |
| } |
| |
| int SoapSerializer:: |
| setSoapBody( SoapBody * pSoapBody) |
| { |
| logEntryEngine("SoapSerializer::setSoapBody") |
| |
| int intStatus = AXIS_FAIL; |
| |
| if(m_pSoapEnvelope) |
| { |
| m_pSoapEnvelope->setSoapBody( pSoapBody); |
| intStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(intStatus) |
| |
| return intStatus; |
| } |
| |
| int SoapSerializer:: |
| setSoapMethod( SoapMethod *pSoapMethod) |
| { |
| logEntryEngine("SoapSerializer::setSoapMethod") |
| |
| int intStatus = AXIS_FAIL; |
| |
| if( m_pSoapEnvelope && (m_pSoapEnvelope->m_pSoapBody)) |
| { |
| if( !(m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod = pSoapMethod; |
| |
| intStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(intStatus) |
| |
| return intStatus; |
| } |
| |
| int SoapSerializer:: |
| addOutputBasicArrayParam( const Axis_Array * pArray, XSDTYPE nType, const AxisChar * pName) |
| { |
| logEntryEngine("SoapSerializer::addOutputBasicArrayParam") |
| |
| int iSuccess = AXIS_SUCCESS; |
| |
| Axis_Array * pLocalArray = (Axis_Array *)NULL; |
| ArrayBean * pAb = (ArrayBean *)NULL; |
| |
| // We need to handle NULL array passed in which means serialize empty array. |
| if (pArray) |
| { |
| pLocalArray = pArray->clone(); |
| pAb = makeArrayBean( nType, pLocalArray->m_Array ); |
| pAb->SetDimension(pLocalArray->m_Size); |
| |
| // We're now finished with the local array object, so it can be deleted |
| // However, we need to de-couple from the internal array, which is now owned |
| // by the ArrayBean. |
| pLocalArray->m_Array = NULL; |
| pLocalArray->m_Size = 0; |
| delete pLocalArray; |
| } |
| else |
| { |
| pAb = makeArrayBean( nType, (void **)NULL ); |
| pAb->SetDimension(0); |
| } |
| |
| Param* pParam = new Param(); |
| |
| pAb->SetItemName(pName); |
| if( RPC_ENCODED == m_nStyle) |
| pParam->setName(pName); |
| else |
| pParam->setName("array"); |
| |
| pParam->m_Value.pArray = pAb; |
| pParam->m_Type = XSD_ARRAY; |
| |
| if( m_pSoapEnvelope && (m_pSoapEnvelope->m_pSoapBody) && |
| (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addOutputParam( pParam); |
| |
| logExitWithReturnCode(iSuccess) |
| |
| return iSuccess; |
| } |
| |
| int SoapSerializer:: |
| addOutputCmplxArrayParam( const Axis_Array * pArray, |
| void * pSZFunct, void * pDelFunct, |
| const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapSerializer::addOutputCmplxArrayParam") |
| |
| int iSuccess = AXIS_SUCCESS; |
| |
| Axis_Array * pLocalArray = (Axis_Array *)NULL; |
| ArrayBean * pAb = (ArrayBean *)NULL; |
| |
| // We need to handle NULL array passed in which means serialize empty array. |
| if (pArray) |
| { |
| pLocalArray = pArray->clone(); |
| pAb = makeArrayBean( pLocalArray->m_Array, pSZFunct, pDelFunct); |
| pAb->SetDimension( pLocalArray->m_Size); |
| |
| // We're now finished with the local array object, so it can be deleted |
| // However, we need to de-couple from the internal array, which is now owned |
| // by the ArrayBean. |
| pLocalArray->m_Array = NULL; |
| pLocalArray->m_Size = 0; |
| delete pLocalArray; |
| } |
| else |
| { |
| pAb = makeArrayBean( (void **)NULL, pSZFunct, pDelFunct); |
| pAb->SetDimension(0); |
| } |
| |
| Param * pParam = new Param(); |
| |
| pAb->SetItemName( pName); |
| if( RPC_ENCODED == m_nStyle) |
| { |
| pAb->SetTypeName( pName); |
| pAb->SetUri( pNamespace); |
| pParam->setName( pName); |
| } |
| else |
| { |
| if( NULL != pNamespace) |
| pParam->setURI( pNamespace); |
| |
| pParam->setName( "array"); |
| } |
| |
| pParam->m_Value.pArray = pAb; |
| pParam->m_Type = XSD_ARRAY; |
| |
| if( m_pSoapEnvelope && |
| (m_pSoapEnvelope->m_pSoapBody) && |
| (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addOutputParam( pParam); |
| |
| pParam->setName( pName); |
| |
| logExitWithReturnCode(iSuccess) |
| |
| return iSuccess; |
| } |
| |
| int SoapSerializer:: |
| addOutputCmplxParam( void * pObject, |
| void * pSZFunct, void * pDelFunct, |
| const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapSerializer::addOutputCmplxParam") |
| |
| int iSuccess = AXIS_FAIL; |
| |
| if ( m_pSoapEnvelope |
| && (m_pSoapEnvelope->m_pSoapBody) |
| && (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| { |
| Param * pParam = new Param(); |
| |
| pParam->m_Value.pCplxObj = new ComplexObjectHandler; |
| pParam->m_Value.pCplxObj->pObject = pObject; |
| pParam->m_Value.pCplxObj->pSZFunct = (AXIS_SERIALIZE_FUNCT) pSZFunct; |
| pParam->m_Value.pCplxObj->pDelFunct = (AXIS_OBJECT_DELETE_FUNCT) pDelFunct; |
| |
| // This check is to ensure backward compatibility...do not remove. It use to be we accepted |
| // null string to indicate non-wrapper style, but this is no longer the case. So we need |
| // to set it to a value. |
| |
| AxisString sName = pName; |
| if (sName.empty()) |
| { |
| sName = m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->getPrefix(); |
| sName += ":"; |
| sName += m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->getMethodName(); |
| } |
| |
| pParam->setName( sName.c_str() ); |
| |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addOutputParam( pParam ); |
| |
| iSuccess = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iSuccess) |
| |
| return iSuccess; |
| } |
| |
| int SoapSerializer:: |
| addFaultDetail( void * pObject, |
| void * pSZFunct, void * pDelFunct, |
| const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapSerializer::addFaultDetail") |
| |
| int iSuccess = AXIS_SUCCESS; |
| Param * pParam = new Param(); |
| |
| pParam->m_Value.pCplxObj = new ComplexObjectHandler; |
| pParam->m_Value.pCplxObj->pObject = pObject; |
| pParam->m_Value.pCplxObj->pSZFunct = (AXIS_SERIALIZE_FUNCT) pSZFunct; |
| pParam->m_Value.pCplxObj->pDelFunct = (AXIS_OBJECT_DELETE_FUNCT) pDelFunct; |
| |
| if( m_pSoapEnvelope && |
| (m_pSoapEnvelope->m_pSoapBody) && |
| (m_pSoapEnvelope->m_pSoapBody->m_pSoapFault)) |
| iSuccess = m_pSoapEnvelope->m_pSoapBody->m_pSoapFault->setFaultDetail(pParam); |
| |
| pParam->setName( pName); |
| |
| logExitWithReturnCode(iSuccess) |
| |
| return iSuccess; |
| } |
| |
| int SoapSerializer:: |
| addFaultDetail( const AxisChar * pDetail) |
| { |
| logEntryEngine("SoapSerializer::addFaultDetail") |
| |
| int iStatus = AXIS_FAIL; |
| if( m_pSoapEnvelope && |
| (m_pSoapEnvelope->m_pSoapBody) && (m_pSoapEnvelope->m_pSoapBody->m_pSoapFault)) |
| { |
| iStatus = m_pSoapEnvelope->m_pSoapBody->m_pSoapFault->setFaultDetail(pDetail); |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| int SoapSerializer:: |
| setSoapFault( SoapFault * pSoapFault) |
| { |
| logEntryEngine("SoapSerializer::setSoapFault") |
| |
| int intStatus = AXIS_FAIL; |
| |
| if( m_pSoapEnvelope && (m_pSoapEnvelope->m_pSoapBody)) |
| { |
| delete m_pSoapEnvelope->m_pSoapBody->m_pSoapFault; |
| |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapFault = pSoapFault; |
| intStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(intStatus) |
| |
| return intStatus; |
| } |
| |
| int SoapSerializer:: |
| setOutputStream( SOAPTransport * pStream) |
| { |
| logEntryEngine("SoapSerializer::setOutputStream") |
| |
| int iStatus = AXIS_SUCCESS; |
| |
| m_pOutputStream = pStream; |
| |
| try |
| { |
| if( m_pSoapEnvelope) |
| { |
| if( checkAttachmentAvailability()) |
| { |
| char *pszSOAPMimeHeaders = pStream->getIncomingSOAPMimeHeaders(); |
| if (NULL != pszSOAPMimeHeaders) |
| { // Server code |
| string asSOAPMimeHeaders = pszSOAPMimeHeaders; |
| int start = asSOAPMimeHeaders.find( AXIS_CONTENT_TYPE); |
| int startPosIdValue = asSOAPMimeHeaders.find( "<", start + strlen( AXIS_CONTENT_ID ":")) + 1; |
| int endPosIdValue = asSOAPMimeHeaders.find( ">", start + strlen( AXIS_CONTENT_TYPE)); |
| int length = endPosIdValue - startPosIdValue ; |
| |
| string asStartID = asSOAPMimeHeaders.substr (startPosIdValue,length); |
| |
| string asContentType( "multipart/related; type=\"text/xml\"; start=\"<"); |
| |
| asContentType = asContentType + asStartID + ">\""; |
| asContentType = asContentType + "; boundary=\"" MIMEBOUNDARY "\""; |
| |
| pStream->setTransportProperty( CONTENT_TYPE, asContentType.c_str()); |
| |
| serialize( "\r\n" MIMEBOUNDARY "\r\n", NULL); |
| serialize( pStream->getIncomingSOAPMimeHeaders(), "\r\n\r\n", NULL); |
| } |
| else |
| { // Client code |
| const char *id = m_pContentIdSet->generateId(); |
| string ctype = "multipart/related; type=\"text/xml\"; boundary=\""; |
| ctype += MIMEBOUNDARY; |
| ctype += "\"; start=\"<"; |
| ctype += id; |
| ctype += ">\""; |
| pStream->deleteTransportProperty(AXIS_CONTENT_TYPE); // Never want 2 Content-Type HTTP headers |
| pStream->setTransportProperty(AXIS_CONTENT_TYPE, ctype.c_str()); |
| |
| serialize("\r\n--" MIMEBOUNDARY "\r\n", NULL); |
| serialize(AXIS_CONTENT_TYPE ": text/xml; charset=UTF-8\r\n", NULL); |
| serialize(AXIS_CONTENT_TRANSFER_ENCODING ": binary\r\n", NULL); |
| |
| string cid = AXIS_CONTENT_ID; |
| cid += ": <"; |
| cid += id; |
| cid += ">\r\n\r\n"; // Extra \r\n terminates headers |
| serialize(cid.c_str(), NULL); |
| } |
| } |
| |
| serialize( "<?xml version='1.0' encoding='utf-8' ?>", NULL); |
| |
| if( (iStatus = m_pSoapEnvelope->serialize( *this, (SOAP_VERSION) m_iSoapVersion)) == AXIS_FAIL) |
| { |
| logThrowExceptionWithData("AxisSoapException - CLIENT_SOAP_MESSAGE_INCOMPLETE", "The SOAP serializer has detected errors in the header or envelope. Transmission has been aborted.") |
| |
| throw AxisSoapException( CLIENT_SOAP_MESSAGE_INCOMPLETE, "The SOAP serializer has detected errors in the header or envelope. Transmission has been aborted."); |
| } |
| |
| if( checkAttachmentAvailability()) |
| serializeAttachments( *this); |
| } |
| } |
| catch( AxisSoapException& e) |
| { |
| e = e; |
| |
| logRethrowException() |
| |
| throw; |
| } |
| catch( AxisException& e) |
| { |
| e = e; |
| |
| logRethrowException() |
| |
| throw; |
| } |
| catch( ...) |
| { |
| logRethrowException() |
| |
| throw; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| /* |
| * Some client side transport layer may wait until the end of buffers is |
| * acknowladged. Use this function to do that. |
| */ |
| void SoapSerializer:: |
| markEndOfStream() |
| { |
| logEntryEngine("SoapSerializer::markEndOfStream") |
| |
| m_pOutputStream->flushOutput(); |
| |
| logExit() |
| } |
| |
| /* |
| * Initializing the members of the class. This is needed since |
| * the same object instance of this class, may be used to server |
| * several SOAP requests. |
| */ |
| int SoapSerializer:: |
| init() |
| { |
| logEntryEngine("SoapSerializer::init") |
| |
| m_nStatus = AXIS_SUCCESS; |
| |
| delete m_pSoapEnvelope; |
| m_pSoapEnvelope= NULL; |
| |
| /* Adding SoapEnvelop and SoapBody to Serializer */ |
| m_pSoapEnvelope = new SoapEnvelope(); |
| m_pSoapEnvelope->setSoapBody( new SoapBody()); |
| |
| m_nCounter=0; |
| m_NsStack.clear(); |
| |
| logExitWithReturnCode(m_nStatus) |
| |
| return m_nStatus; |
| } |
| |
| int SoapSerializer:: |
| setSoapVersion( SOAP_VERSION nSoapVersion) |
| { |
| logEntryEngine("SoapSerializer::setSoapVersion") |
| |
| m_iSoapVersion = nSoapVersion; |
| |
| m_pSoapEnvelope->clearStandardNamespaceDecl(); // Samisa : AXISCPP-368 |
| |
| /* here the default namespaces of the SoapEnvelop should be added and |
| * intialized as well. |
| */ |
| m_pSoapEnvelope->addStandardNamespaceDecl( SoapKeywordMapping::map(nSoapVersion).pEnv); |
| m_pSoapEnvelope->addStandardNamespaceDecl( SoapKeywordMapping::map(nSoapVersion).pXsd); |
| m_pSoapEnvelope->addStandardNamespaceDecl( SoapKeywordMapping::map(nSoapVersion).pXsi); |
| |
| /* Adding the standard SOAP namespace to the namespace stack */ |
| m_NsStack[SoapKeywordMapping::map(nSoapVersion).pchNamespaceUri] = |
| SoapKeywordMapping::map(nSoapVersion).pchPrefix; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| void SoapSerializer:: |
| removeNamespacePrefix( const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapSerializer::removeNamespacePrefix") |
| |
| if( m_NsStack.find( pNamespace) != m_NsStack.end()) |
| m_NsStack.erase( pNamespace); |
| |
| logExit() |
| } |
| |
| const AxisChar * SoapSerializer:: |
| getNamespacePrefix( const AxisChar * pNamespace) |
| { |
| bool blnIsNewPrefix; |
| return getNamespacePrefix(pNamespace, blnIsNewPrefix); |
| } |
| |
| const AxisChar * SoapSerializer:: |
| getNamespacePrefix( const AxisChar * pNamespace, bool & blnIsNewPrefix) |
| { |
| blnIsNewPrefix = false; |
| |
| // We will not map null or null string namespaces...MUST return null string |
| // since the namespace is sometimes assigned to object of type string class. |
| if (pNamespace == (const AxisChar *)NULL || pNamespace[0] == '\0') |
| return (const AxisChar *)""; |
| |
| if( m_NsStack.find( pNamespace) == m_NsStack.end()) |
| { |
| m_nCounter++; |
| AxisSprintf(m_Buf, 8, "ns%d", m_nCounter); |
| m_NsStack[pNamespace] = m_Buf; |
| blnIsNewPrefix = true; |
| } |
| |
| return m_NsStack[pNamespace].c_str(); |
| } |
| |
| IWrapperSoapSerializer& SoapSerializer:: |
| operator << (const AxisChar * cSerialized) |
| { |
| logSetFunctionNameEngine("SoapSerializer::operator <<") |
| |
| // some thing has gone wrong. So do nothing |
| if( AXIS_SUCCESS != m_nStatus) |
| return *this; |
| |
| try |
| { |
| // send everything to transport layer, it should handle bufferization itself |
| m_pOutputStream->sendBytes( cSerialized, 0); |
| } |
| catch(AxisSoapException& e) |
| { |
| e = e; |
| |
| logRethrowException() |
| |
| throw; |
| } |
| catch(AxisException& e) |
| { |
| e = e; |
| |
| logRethrowException() |
| |
| throw; |
| } |
| catch(...) |
| { |
| logRethrowException() |
| |
| throw; |
| } |
| |
| return *this; |
| } |
| |
| // deprecated..... |
| int SoapSerializer:: |
| createSoapMethod( const AxisChar * sLocalName, |
| const AxisChar * sURI) |
| { |
| return createSoapMethod(sLocalName, sURI, true); |
| } |
| |
| int SoapSerializer:: |
| createSoapMethod( const AxisChar * sLocalName, |
| const AxisChar * sURI, |
| bool bIsWrapperStyle) |
| { |
| logEntryEngine("SoapSerializer::createSoapMethod") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapBody) |
| { |
| SoapMethod * pMethod = m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod; |
| if (pMethod == NULL) |
| { |
| pMethod = new SoapMethod(); |
| setSoapMethod( pMethod); |
| } |
| |
| // Ensure everything is cleared out if using existing method object. |
| pMethod->reset(); |
| |
| pMethod->setWrapperStyle(bIsWrapperStyle); |
| pMethod->setLocalName( sLocalName); |
| pMethod->setPrefix( getNamespacePrefix(sURI) ); |
| pMethod->setURI( sURI); |
| |
| // Since we want the bean to define the namespace for non-wrapper style, we need to reset |
| // the counter. See SoapMethod::serialize() for further information. |
| if (!bIsWrapperStyle) |
| m_nCounter = 0; |
| |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| int SoapSerializer:: |
| createSoapFault( const AxisChar * sLocalName, |
| const AxisChar * sURI, |
| const AxisChar * sFaultCode, |
| const AxisChar * sFaultString) |
| { |
| logEntryEngine("SoapSerializer::createSoapFault") |
| |
| SoapFault * pSoapFault = new SoapFault(); |
| |
| setSoapFault( pSoapFault); |
| |
| pSoapFault->setLocalName( sLocalName); |
| pSoapFault->setPrefix( getNamespacePrefix( sURI)); |
| pSoapFault->setURI( sURI); |
| pSoapFault->setFaultcode( sFaultCode); |
| pSoapFault->setFaultstring( sFaultString); |
| |
| char* pcNodeName = g_pConfig->getAxisConfProperty( AXCONF_NODENAME); |
| char* pcPort = g_pConfig->getAxisConfProperty(AXCONF_LISTENPORT); |
| string strUrl = pcNodeName; |
| strUrl += ":"; |
| strUrl += string( pcPort); |
| pSoapFault->setFaultactor( strUrl.c_str()); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| /* |
| * Used to create an ArrayBean when the return type of a method is an array |
| * of basic types |
| */ |
| ArrayBean * SoapSerializer:: |
| makeArrayBean( XSDTYPE nType, void ** pArray) |
| { |
| logEntryEngine("SoapSerializer::makeArrayBean") |
| |
| ArrayBean* pAb = new ArrayBean(); |
| |
| pAb->m_type = nType; |
| pAb->m_value.sta = pArray; |
| |
| logExitWithPointer(pAb) |
| |
| return pAb; |
| } |
| |
| /* |
| * Used to create an ArrayBean when the return type of a method is an array |
| * of complex types |
| */ |
| ArrayBean * SoapSerializer:: |
| makeArrayBean(void ** pObject, void * pSZFunct, void * pDelFunct) |
| { |
| logEntryEngine("SoapSerializer::makeArrayBean") |
| |
| ArrayBean* pAb = new ArrayBean(); |
| |
| pAb->m_type = USER_TYPE; |
| pAb->m_value.cta = new ComplexObjectHandler; |
| pAb->m_value.cta->pSZFunct = (AXIS_SERIALIZE_FUNCT) pSZFunct; |
| pAb->m_value.cta->pDelFunct = (AXIS_OBJECT_DELETE_FUNCT) pDelFunct; |
| pAb->m_value.cta->pObject = pObject; |
| |
| logExitWithPointer(pAb) |
| |
| return pAb; |
| } |
| |
| IHeaderBlock * SoapSerializer:: |
| createHeaderBlock() |
| { |
| logEntryEngine("SoapSerializer::createHeaderBlock") |
| |
| HeaderBlock * pHeaderBlock= new HeaderBlock(); |
| |
| setHeaderBlock( pHeaderBlock); |
| |
| logExitWithPointer(pHeaderBlock) |
| |
| return pHeaderBlock; |
| } |
| |
| int SoapSerializer:: |
| setHeaderBlock( HeaderBlock * pHeaderBlock) |
| { |
| logEntryEngine("SoapSerializer::setHeaderBlock") |
| |
| int intStatus = AXIS_FAIL; |
| |
| if( (m_pSoapEnvelope) && (m_pSoapEnvelope->m_pSoapHeader)) |
| { |
| /* no need to create a SOAP Header, it already exists */ |
| } |
| else |
| { |
| SoapHeader * pSoapHeader = new SoapHeader(); |
| setSoapHeader( pSoapHeader); |
| } |
| |
| m_pSoapEnvelope->m_pSoapHeader->addHeaderBlock( pHeaderBlock); |
| intStatus = AXIS_SUCCESS; |
| |
| logExitWithReturnCode(intStatus) |
| |
| return intStatus; |
| } |
| |
| /* |
| * This method not only removes the existing SoapHeader, but also removes |
| * all the existing HeaderBlocks which are associated with this SoapHeader. |
| * Therefore the caller of this method has to be exactly sure whether he wants |
| * to do this. |
| */ |
| int SoapSerializer:: |
| removeSoapHeader() |
| { |
| logEntryEngine("SoapSerializer::removeSoapHeader") |
| |
| delete m_pSoapEnvelope->m_pSoapHeader; |
| m_pSoapEnvelope->m_pSoapHeader= NULL; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| /* |
| * Used to Serialize an array of complex types inside a complex type. Called |
| * from within the Serialize wrapper method of the complex type. |
| */ |
| int SoapSerializer:: |
| serializeCmplxArray( const Axis_Array * pArray, |
| void * pSZFunct, void * pDelFunct, |
| const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapSerializer::serializeCmplxArray") |
| |
| ArrayBean * pAb = (ArrayBean *)NULL; |
| |
| // We need to handle NULL array passed in which means serialize empty array. |
| if (pArray) |
| { |
| pAb = (ArrayBean*) makeArrayBean( pArray->m_Array, pSZFunct, pDelFunct); |
| pAb->SetDimension( pArray->m_Size); |
| } |
| else |
| { |
| pAb = (ArrayBean*) makeArrayBean( (void **)NULL, pSZFunct, pDelFunct); |
| pAb->SetDimension(0); |
| } |
| |
| Param * pParam = new Param(); |
| |
| pAb->SetItemName( pName); |
| if( RPC_ENCODED == m_nStyle) |
| { |
| pAb->SetTypeName( pName); |
| pAb->SetUri( pNamespace); |
| pParam->setName( pName); |
| } |
| else |
| pParam->setName( "array"); |
| |
| pParam->m_Value.pArray = pAb; |
| pParam->m_Type = XSD_ARRAY; |
| |
| if( pNamespace != NULL) |
| { |
| bool blnIsNewNamespacePrefix = false; |
| const AxisChar* np = getNamespacePrefix( pNamespace, blnIsNewNamespacePrefix); |
| const AxisChar* originalNamespace = getNamespace(); // Store original namespace |
| |
| pParam->setPrefix( np); |
| |
| if( blnIsNewNamespacePrefix) |
| removeNamespacePrefix( pNamespace); |
| |
| setNamespace( pNamespace); |
| pParam->serialize( *this); |
| setNamespace( originalNamespace); // Revert back original namespace |
| } |
| else |
| pParam->serialize( *this); |
| |
| /* Remove pointer to the array from the ArrayBean to avoid deleting the |
| * array when ArrayBean is deleted. Array will be deleted when the complex |
| * type that contains this array is deleted */ |
| pAb->RemoveArrayPointer(); |
| delete pParam; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| /* |
| * Used to Serialize an array of basic types inside a complex type. Called from |
| * within the Serialize wrapper method of the complex type. |
| */ |
| int SoapSerializer:: |
| serializeBasicArray( const Axis_Array * pArray, XSDTYPE nType, const AxisChar * pName) |
| { |
| return serializeBasicArray( pArray, NULL, nType, pName); |
| } |
| |
| /* |
| * Used to Serialize an array of basic types inside a complex type. Contains |
| * the namespace so that it can be serialized. Called from within the Serialize |
| * wrapper method of the complex type. |
| */ |
| int SoapSerializer:: |
| serializeBasicArray(const Axis_Array* pArray, |
| const AxisChar* pNamespace, XSDTYPE nType, const AxisChar* pName) |
| { |
| logEntryEngine("SoapSerializer::serializeBasicArray") |
| |
| ArrayBean * pAb = (ArrayBean *)NULL; |
| |
| // We need to handle NULL array passed in which means serialize empty array. |
| if (pArray) |
| { |
| pAb = (ArrayBean*) makeArrayBean( nType, pArray->m_Array); |
| pAb->SetDimension( pArray->m_Size); |
| } |
| else |
| { |
| pAb = (ArrayBean*) makeArrayBean( nType, (void **)NULL); |
| pAb->SetDimension(0); |
| } |
| |
| Param * pParam = new Param(); |
| |
| pAb->SetItemName( pName); |
| if( RPC_ENCODED == m_nStyle) |
| pParam->setName( pName); |
| else |
| pParam->setName( "array"); |
| |
| pParam->m_Value.pArray = pAb; |
| pParam->m_Type = XSD_ARRAY; |
| |
| if( pNamespace != NULL) |
| { |
| bool blnIsNewNamespacePrefix = false; |
| const AxisChar * np = getNamespacePrefix( pNamespace, blnIsNewNamespacePrefix); |
| const AxisChar * originalNamespace = getNamespace(); // Store original namespace |
| |
| pParam->setPrefix( np); |
| |
| if( blnIsNewNamespacePrefix) |
| removeNamespacePrefix( pNamespace); |
| |
| setNamespace( pNamespace); |
| pParam->serialize( *this); |
| setNamespace( originalNamespace); // Revert back original namespace |
| } |
| else |
| pParam->serialize( *this); |
| |
| /* Remove pointer to the array from the ArrayBean to avoid deleting the |
| * array when ArrayBean is deleted. Array will be deleted when the complex |
| * type that contains this array is deleted |
| */ |
| pAb->RemoveArrayPointer(); |
| delete pParam; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| #ifdef UNIT_TESTING_ON |
| int SoapSerializer::setOutputStreamForTesting(SOAPTransport* pStream) |
| { |
| m_pOutputStream = pStream; |
| |
| return AXIS_SUCCESS; |
| } |
| #endif |
| |
| /* |
| * Basic output parameter going to be serialized as an Element later |
| */ |
| int SoapSerializer:: |
| addOutputParam( const AxisChar * pchName, // prefix and element name |
| void * pValue, // value |
| XSDTYPE type) // type |
| { |
| logEntryEngine("SoapSerializer::addOutputParam") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if ( m_pSoapEnvelope |
| && (m_pSoapEnvelope->m_pSoapBody) |
| && (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| { |
| IAnySimpleType* xsdValue = AxisUtils::createSimpleTypeObject(pValue, type); |
| |
| Param * pParam = new Param(); |
| |
| pParam->m_Type = type; |
| pParam->m_sName = pchName; |
| pParam->setValue(type, xsdValue); |
| |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addOutputParam( pParam ); |
| |
| // if non-wrapper then we need to add namespace to envelope since it will not get added |
| // any other way. non-wrapper support was added later so that is why we are in this mess. |
| if (!(m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->isWrapperStyle())) |
| { |
| addNamespaceToEnvelope((AxisChar * )m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->getUri().c_str(), |
| (AxisChar * )m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->getPrefix().c_str()); |
| } |
| |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| int SoapSerializer:: |
| serializeAsElement( const AxisChar * pName, |
| void * pValue, |
| XSDTYPE type) |
| { |
| return serializeAsElement( pName, NULL, pValue, type); |
| } |
| |
| int SoapSerializer:: |
| serializeAsElement( const AxisChar * pName, |
| const AxisChar * pNamespace, |
| void * pValue, |
| XSDTYPE type) |
| { |
| IAnySimpleType* pSimpleType = AxisUtils::createSimpleTypeObject(pValue, type); |
| int ret; |
| ret = serializeAsElement(pName, pNamespace, pSimpleType); |
| delete pSimpleType; |
| |
| return ret; |
| } |
| int SoapSerializer:: |
| serializeAsElement( const AxisChar * pName, |
| IAnySimpleType * pSimpleType) |
| { |
| return serializeAsElement( pName, NULL, pSimpleType); |
| } |
| |
| int SoapSerializer:: |
| serializeAsElement( const AxisChar * pName, |
| const AxisChar * pNamespace, |
| IAnySimpleType * pSimpleType) |
| { |
| logEntryEngine("SoapSerializer::serializeAsElement") |
| |
| int iStatus = AXIS_FAIL; |
| |
| const AxisChar* pPrefix = NULL; |
| bool blnIsNewPrefix = false; |
| |
| if( pNamespace) |
| pPrefix = getNamespacePrefix( pNamespace, blnIsNewPrefix); |
| |
| const AxisChar * pSerialized = NULL; |
| |
| if( blnIsNewPrefix) |
| { |
| pSerialized = m_BTSZ.serializeAsElement( pName, pPrefix, pNamespace, pSimpleType); |
| removeNamespacePrefix( pNamespace); |
| } |
| else |
| pSerialized = m_BTSZ.serializeAsElement( pName, pPrefix, pSimpleType); |
| |
| if( pSerialized) |
| { |
| *this << pSerialized; |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| int SoapSerializer:: |
| serializeAsAttribute( const AxisChar * pName, |
| const AxisChar * pNamespace, |
| void * pValue, |
| XSDTYPE type) |
| { |
| IAnySimpleType* pSimpleType = AxisUtils::createSimpleTypeObject(pValue, type); |
| |
| int status = serializeAsAttribute(pName, pNamespace, pSimpleType); |
| delete pSimpleType; |
| |
| return status; |
| } |
| |
| int SoapSerializer:: |
| serializeAsAttribute( const AxisChar * pName, |
| const AxisChar * pNamespace, |
| IAnySimpleType* pSimpleType) |
| { |
| logEntryEngine("SoapSerializer::serializeAsAttribute") |
| |
| int iStatus = AXIS_FAIL; |
| |
| const AxisChar * pPrefix = NULL; |
| |
| if( pNamespace) |
| pPrefix = getNamespacePrefix( pNamespace); |
| |
| const AxisChar * pSerialized = m_BTSZ.serializeAsAttribute(pName, pPrefix, pSimpleType); |
| |
| if( pSerialized) |
| { |
| *this << pSerialized; |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| void SoapSerializer:: |
| serializeVargs( const char * pFirst, va_list vList) |
| { |
| logEntryEngine("SoapSerializer::serializeVargs") |
| |
| const char * pArg; |
| |
| if( pFirst) |
| *this << pFirst; |
| |
| do |
| { |
| pArg = va_arg( vList, const char*); |
| |
| if( pArg) |
| *this << pArg; |
| } |
| while( pArg != NULL); |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| serialize( const char * pFirst, ...) |
| { |
| logEntryEngine("SoapSerializer::serialize") |
| |
| va_list vList; |
| |
| va_start( vList, pFirst ); |
| serializeVargs(pFirst, vList); |
| va_end( vList); |
| |
| logExit() |
| } |
| |
| /* |
| * Used probably by a handler to add a header block to the Serializer. |
| */ |
| int SoapSerializer:: |
| addHeaderBlock( IHeaderBlock * pBlk) |
| { |
| logEntryEngine("SoapSerializer::addHeaderBlock") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if( m_pSoapEnvelope) |
| { |
| if( !m_pSoapEnvelope->m_pSoapHeader) |
| m_pSoapEnvelope->m_pSoapHeader = new SoapHeader(); |
| |
| m_pSoapEnvelope->m_pSoapHeader->addHeaderBlock( (HeaderBlock *) pBlk); |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| int SoapSerializer:: |
| setBodyAsHexBinary( xsd__hexBinary body) |
| { |
| /* TODO */ |
| return AXIS_SUCCESS; |
| } |
| |
| int SoapSerializer:: |
| setBodyAsBase64Binary( xsd__base64Binary body) |
| { |
| /* TODO */ |
| return AXIS_SUCCESS; |
| } |
| |
| const AxisChar* SoapSerializer:: |
| getBodyAsString() |
| { |
| /* TODO */ |
| return NULL; |
| } |
| |
| /* following two functions are needed by serializer functions of complex types |
| * for RPC style web services |
| */ |
| void SoapSerializer:: |
| serializeStartElementOfType( const AxisChar * pName, |
| const AxisChar * pNamespace, |
| const AxisChar * pPrefix) |
| { |
| if( pPrefix) |
| { |
| serialize( "<", |
| pName, |
| " xsi:type=", |
| PLATFORM_DOUBLE_QUOTE_S, pPrefix, ":", pName, PLATFORM_DOUBLE_QUOTE_S, |
| " xmlns:", |
| pPrefix, "=", |
| PLATFORM_DOUBLE_QUOTE_S, pNamespace, PLATFORM_DOUBLE_QUOTE_S, ">", NULL); |
| } |
| else |
| serialize( "<", pName, ">", NULL); |
| } |
| |
| void SoapSerializer:: |
| serializeEndElementOfType( const AxisChar * pName) |
| { |
| serialize( "</", pName, ">", NULL); |
| } |
| |
| IHeaderBlock * SoapSerializer:: |
| createHeaderBlock( const AxisChar * pachLocalName, |
| const AxisChar * pachUri) |
| { |
| logEntryEngine("SoapSerializer::createHeaderBlock") |
| |
| HeaderBlock * pHeaderBlock= new HeaderBlock( pachLocalName, pachUri); |
| |
| setHeaderBlock( pHeaderBlock); |
| |
| logExitWithPointer(pHeaderBlock) |
| |
| return pHeaderBlock; |
| } |
| |
| SoapMethod * SoapSerializer:: |
| getSOAPMethod() |
| { |
| logEntryEngine("SoapSerializer::getSOAPMethod") |
| |
| SoapMethod * returnValue = NULL; |
| |
| if ( m_pSoapEnvelope && (m_pSoapEnvelope->m_pSoapBody)) |
| returnValue = m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod; |
| |
| logExitWithPointer(returnValue) |
| |
| return returnValue; |
| } |
| |
| int SoapSerializer:: |
| setSOAPMethodAttribute( Attribute * pAttribute) |
| { |
| logEntryEngine("SoapSerializer::setSOAPMethodAttribute") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if( m_pSoapEnvelope && |
| (m_pSoapEnvelope->m_pSoapBody) && |
| (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| { |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addAttribute( pAttribute); |
| |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| void SoapSerializer:: |
| clearSOAPMethodAttributes() |
| { |
| logEntryEngine("SoapSerializer::clearSOAPMethodAttributes") |
| |
| if (m_pSoapEnvelope && m_pSoapEnvelope->m_pSoapBody |
| && m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod) |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->clearAttributes(); |
| |
| logExit() |
| } |
| |
| int SoapSerializer:: |
| serializeAnyObject( AnyType * pAnyObject) |
| { |
| logEntryEngine("SoapSerializer::serializeAnyObject") |
| |
| for( int i = 0; i < pAnyObject->_size; i++) |
| serialize( pAnyObject->_array[i], 0); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int SoapSerializer:: |
| addOutputAnyObject( AnyType * pAnyObject) |
| { |
| logEntryEngine("SoapSerializer::addOutputAnyObject") |
| |
| Param * pParam = new Param(); |
| |
| pParam->m_Type = XSD_ANY; |
| pParam->m_Value.pAnyObject = pAnyObject; |
| |
| if( m_pSoapEnvelope && |
| (m_pSoapEnvelope->m_pSoapBody) && |
| (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addOutputParam( pParam); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| IHeaderBlock * SoapSerializer:: |
| getHeaderBlock( const AxisChar * pcName, |
| const AxisChar * pcNamespace) |
| { |
| logEntryEngine("SoapSerializer::getHeaderBlock") |
| |
| IHeaderBlock * returnValue = NULL; |
| |
| // there has been no <Header> element so there can be no Header blocks |
| if (m_pSoapEnvelope && m_pSoapEnvelope->m_pSoapHeader) |
| returnValue = m_pSoapEnvelope->m_pSoapHeader->getHeaderBlock( pcName, pcNamespace, false); |
| |
| logExitWithPointer(returnValue) |
| |
| return returnValue; |
| } |
| |
| IHeaderBlock * SoapSerializer:: |
| getFirstHeaderBlock() |
| { |
| return m_pSoapEnvelope->m_pSoapHeader->getFirstHeaderBlock(); |
| } |
| |
| IHeaderBlock * SoapSerializer:: |
| getNextHeaderBlock() |
| { |
| return m_pSoapEnvelope->m_pSoapHeader->getNextHeaderBlock(); |
| } |
| |
| int SoapSerializer:: |
| serializeAsChardata( void * pValue, XSDTYPE type) |
| { |
| logEntryEngine("SoapSerializer::serializeAsChardata") |
| |
| char * pStr = m_Buf; |
| |
| IAnySimpleType* pSimpleType = AxisUtils::createSimpleTypeObject(pValue, type); |
| pStr = pSimpleType->serialize(); |
| |
| *this << pStr; |
| |
| delete pSimpleType; |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| void SoapSerializer:: |
| serializeAttachments( SoapSerializer &pSZ) |
| { |
| logEntryEngine("SoapSerializer::serializeAttachments") |
| |
| /*serializing the attachments*/ |
| map<AxisXMLString, ISoapAttachment*>::iterator itCurrAttach= m_SoapAttachments.begin(); |
| while( itCurrAttach != m_SoapAttachments.end()) |
| { |
| SoapAttachment *att = ((SoapAttachment *) ((*itCurrAttach).second)); |
| if (NULL != att->getBody()) |
| { |
| serialize( "\r\n--" MIMEBOUNDARY, NULL); |
| att->serialize(pSZ); |
| } |
| itCurrAttach++; |
| } |
| pSZ.serialize("\r\n--" MIMEBOUNDARY "--\r\n", NULL); |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| addAttachment( const AxisChar * achId, ISoapAttachment * pAttach) |
| { |
| m_SoapAttachments[achId] = pAttach; |
| } |
| |
| void SoapSerializer:: |
| addAttachments(ISoapAttachment** pAttach, int iAttchArraySize) |
| { |
| for (int i=0; i < iAttchArraySize; i++) |
| { |
| const char *id = ((ISoapAttachment*)pAttach[i])->getAttachmentId(); |
| m_SoapAttachments[id] = pAttach[i]; |
| } |
| |
| } |
| |
| void SoapSerializer:: |
| addAttachmentHeader(const AxisChar * achId, |
| const AxisChar * achHeaderName, |
| const AxisChar * achHeaderValue) |
| { |
| |
| if (m_SoapAttachments[achId] == NULL) |
| m_SoapAttachments[achId] = new SoapAttachment(m_pContentIdSet); |
| |
| m_SoapAttachments[achId]->addHeader( achHeaderName, achHeaderValue); |
| } |
| |
| void SoapSerializer:: |
| addAttachmentBody( const AxisChar * achId, |
| xsd__base64Binary * pAttchBody) |
| { |
| if( m_SoapAttachments[achId] == NULL) |
| m_SoapAttachments[achId] = new SoapAttachment(m_pContentIdSet); |
| |
| m_SoapAttachments[achId]->addBody( pAttchBody); |
| } |
| |
| void SoapSerializer:: |
| addNamespaceToEnvelope( AxisChar * pachNamespaceURI, |
| AxisChar * pachPrefix) |
| { |
| logEntryEngine("SoapSerializer::addNamespaceToEnvelope") |
| |
| std::list<Attribute*> attributeList; |
| Attribute * pNameSpace = new Attribute( attributeList, pachPrefix, "xmlns", pachNamespaceURI); |
| |
| m_pSoapEnvelope->addNamespaceDecl( pNameSpace); |
| |
| addNamespaceToNamespaceList( pachNamespaceURI, pachPrefix); |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| addNamespaceToNamespaceList( const AxisChar * pachNamespaceURI, |
| const AxisChar * pachPrefix) |
| { |
| m_NsStack[pachNamespaceURI] = pachPrefix; |
| } |
| |
| ISoapAttachment* SoapSerializer:: |
| createSoapAttachment() |
| { |
| return new SoapAttachment(m_pContentIdSet); |
| } |
| |
| void SoapSerializer:: |
| setContentIdSet(ContentIdSet *pContentIdSet) |
| { |
| m_pContentIdSet = pContentIdSet; |
| } |
| |
| bool SoapSerializer:: |
| checkAttachmentAvailability() |
| { |
| map<AxisXMLString, ISoapAttachment*>::iterator itCurrAttach= m_SoapAttachments.begin(); |
| |
| if( itCurrAttach != m_SoapAttachments.end()) |
| return true; |
| |
| return false; |
| } |
| |
| void SoapSerializer:: |
| addAttachmentParameter(ISoapAttachment* att, const char* pName, IAttribute **attributes, int nAttributes) |
| { |
| if (NULL==att) |
| att = static_cast<ISoapAttachment*>(new SoapAttachment(m_pContentIdSet)); |
| SoapAttachmentReference *ref = new SoapAttachmentReference(static_cast<SoapAttachment*>(att)); |
| m_attachmentRefs.push_back(ref); |
| |
| Param *pParam = new Param(); |
| pParam->m_Value.pAttachmentRef = ref; |
| pParam->m_Type = ATTACHMENT; |
| |
| if (NULL!=attributes && nAttributes>0) |
| ref->addAttributes(attributes,nAttributes); |
| |
| if (m_pSoapEnvelope && |
| (m_pSoapEnvelope->m_pSoapBody) && |
| (m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod)) |
| m_pSoapEnvelope->m_pSoapBody->m_pSoapMethod->addOutputParam(pParam); |
| |
| pParam->setName(pName); |
| m_SoapAttachments[att->getAttachmentId()] = att; |
| } |
| |
| IHeaderBlock * SoapSerializer:: |
| getCurrentHeaderBlock() |
| { |
| return m_pSoapEnvelope->m_pSoapHeader->getCurrentHeaderBlock(); |
| } |
| |
| AxisXMLString SoapSerializer:: |
| getNamespaceURL( string sNameSpace) |
| { |
| // Check that the namespace value is not empty. If it is then return as |
| // there is nothing to do! |
| if( sNameSpace.empty()) |
| return "nothing to do"; |
| |
| // Iterate through the namespace stack. If the namespace can be found, then |
| // return the associated uri. |
| map <AxisXMLString, AxisXMLString>::iterator iterator = m_NsStack.begin(); |
| |
| while( iterator != m_NsStack.end()) |
| { |
| AxisXMLString sIt_URI = iterator->first; |
| AxisXMLString sIt_NameSpace = iterator->second; |
| |
| if( sNameSpace == sIt_NameSpace) |
| return iterator->first; |
| else |
| iterator++; |
| } |
| |
| if (NULL==m_pSoapEnvelope->m_pSoapHeader) return ""; |
| |
| // Couldn't find the namespace in the namespace list. Try trawling through the |
| // SOAP headers looking to see if any of their children have defined any |
| // namespaces. |
| IHeaderBlock * pHeaderBlock = m_pSoapEnvelope->m_pSoapHeader->getFirstHeaderBlock(); |
| |
| while( pHeaderBlock != NULL) |
| { |
| for( int iChildIndex = 0; iChildIndex < pHeaderBlock->getNoOfChildren(); iChildIndex++) |
| { |
| BasicNode * pChild = pHeaderBlock->getChild( iChildIndex + 1); |
| |
| if( pChild != NULL) |
| if( !strcmp( sNameSpace.c_str(), pChild->getPrefix())) |
| return pChild->getURI(); |
| } |
| |
| pHeaderBlock = m_pSoapEnvelope->m_pSoapHeader->getNextHeaderBlock(); |
| } |
| |
| // Couldn't find the namespace in the namespace list or in children. Try |
| // trawling through the SOAP headers looking to see if any of their attributes |
| // have defined any namespaces. |
| char * pszNameSpace = (char *) sNameSpace.c_str(); |
| char * pszValue = NULL; |
| |
| pHeaderBlock = m_pSoapEnvelope->m_pSoapHeader->getFirstHeaderBlock(); |
| |
| while( pHeaderBlock != NULL && pszValue == NULL) |
| { |
| pszValue = (char *) pHeaderBlock->getAttributeUri( "", pszNameSpace); |
| pHeaderBlock = m_pSoapEnvelope->m_pSoapHeader->getNextHeaderBlock(); |
| } |
| |
| if( pszValue == NULL) |
| return ""; |
| |
| return pszValue; |
| } |
| |
| |
| int SoapSerializer:: |
| deleteHeaderBlock( const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapSerializer::deleteHeaderBlock") |
| |
| int iStatus = AXIS_SUCCESS; |
| |
| iStatus = m_pSoapEnvelope->m_pSoapHeader->deleteHeaderBlock( pName, pNamespace); |
| |
| //No remaining soap header blocks, so will delete the SoapHeader |
| if( iStatus == AXIS_NO_REMAINING_SOAP_HEADERS) |
| { |
| delete m_pSoapEnvelope->m_pSoapHeader; |
| m_pSoapEnvelope->m_pSoapHeader = NULL; |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| void SoapSerializer:: |
| reset() |
| { |
| logEntryEngine("SoapSerializer::reset") |
| |
| // reset namespace prefix counter and stack |
| m_nCounter = 0; |
| m_NsStack.clear(); |
| |
| if( m_pSoapEnvelope ) |
| m_pSoapEnvelope->reset(); |
| |
| m_pStub = NULL; |
| |
| logExit() |
| } |
| |
| |
| void SoapSerializer:: |
| addNamespaceToSOAPHeader(const AxisChar *pachNamespaceURI, const AxisChar* pachPrefix) |
| { |
| logEntryEngine("SoapSerializer::addNamespaceToSOAPHeader") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapHeader) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, pachPrefix, "xmlns", pachNamespaceURI); |
| |
| m_pSoapEnvelope->m_pSoapHeader->addNamespaceDecl(pAttribute); |
| } |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| addAttributeToSOAPHeader(const AxisChar *pLocalname, const AxisChar *pPrefix, const AxisChar *pValue) |
| { |
| logEntryEngine("SoapSerializer::addAttributeToSOAPHeader") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapHeader) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, pLocalname, pPrefix, pValue); |
| |
| m_pSoapEnvelope->m_pSoapHeader->addAttribute(pAttribute); |
| } |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| clearSOAPHeaderAttributes() |
| { |
| logEntryEngine("SoapSerializer::clearSOAPHeaderAttributes") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapHeader) |
| m_pSoapEnvelope->m_pSoapHeader->clearAttributes(); |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| clearSOAPHeaderNamespaces() |
| { |
| logEntryEngine("SoapSerializer::clearSOAPHeaderNamespaces") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapHeader) |
| m_pSoapEnvelope->m_pSoapHeader->clearNamespaceDecls(); |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| addNamespaceToSOAPBody(const AxisChar *pachNamespaceURI, const AxisChar* pachPrefix) |
| { |
| logEntryEngine("SoapSerializer::addNamespaceToSOAPBody") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapBody) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, pachPrefix, "xmlns", pachNamespaceURI); |
| |
| m_pSoapEnvelope->m_pSoapBody->addNamespaceDecl(pAttribute); |
| } |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| addAttributeToSOAPBody(const AxisChar *pLocalname, const AxisChar *pPrefix, const AxisChar *pValue) |
| { |
| logEntryEngine("SoapSerializer::addAttributeToSOAPBody") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapBody) |
| { |
| std::list<Attribute*> attributeList; |
| Attribute * pAttribute = new Attribute( attributeList, pLocalname, pPrefix, pValue); |
| |
| m_pSoapEnvelope->m_pSoapBody->addAttribute(pAttribute); |
| } |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| clearSOAPBodyAttributes() |
| { |
| logEntryEngine("SoapSerializer::clearSOAPBodyAttributes") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapBody) |
| m_pSoapEnvelope->m_pSoapBody->clearAttributes(); |
| |
| logExit() |
| } |
| |
| void SoapSerializer:: |
| clearSOAPBodyNamespaces() |
| { |
| logEntryEngine("SoapSerializer::clearSOAPBodyNamespaces") |
| |
| if (m_pSoapEnvelope |
| && m_pSoapEnvelope->m_pSoapBody) |
| m_pSoapEnvelope->m_pSoapBody->clearNamespaceDecls(); |
| |
| logExit() |
| } |
| AXIS_CPP_NAMESPACE_END |
