| /* -*- C++ -*- */ |
| /* |
| * Copyright 2003-2004 The Apache Software Foundation. |
| * |
| * 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 "../../soap/SoapBody.h" |
| #include "../../soap/SoapMethod.h" |
| #include "ServerAxisEngine.h" |
| #include <stdio.h> |
| #include "../../common/AxisUtils.h" |
| #include "../../wsdd/WSDDDeployment.h" |
| #include "../HandlerPool.h" |
| #include "../../common/AxisTrace.h" |
| |
| extern AXIS_CPP_NAMESPACE_PREFIX HandlerPool *g_pHandlerPool; |
| extern AXIS_CPP_NAMESPACE_PREFIX WSDDDeployment *g_pWSDDDeployment; |
| |
| AXIS_CPP_NAMESPACE_START |
| ServerAxisEngine:: |
| ServerAxisEngine () |
| { |
| logEntryEngine("ServerAxisEngine::ServerAxisEngine") |
| |
| m_pWebService = NULL; |
| |
| logExit() |
| } |
| |
| ServerAxisEngine:: |
| ~ServerAxisEngine () |
| { |
| logEntryEngine("ServerAxisEngine::~ServerAxisEngine") |
| |
| logExit() |
| } |
| |
| int ServerAxisEngine:: |
| process (SOAPTransport * pStream) |
| { |
| logEntryEngine("ServerAxisEngine::process") |
| |
| int Status = 0; |
| int nSoapVersion; |
| try |
| { |
| if (!pStream) |
| { |
| logThrowException("AxisConfigException - SERVER_CONFIG_TRANSPORT_CONF_FAILED") |
| |
| throw AxisConfigException (SERVER_CONFIG_TRANSPORT_CONF_FAILED); |
| } |
| string sSessionId = pStream->getSessionId (); |
| |
| // After this point we should return AXIS_SUCCESS. Otherwise the transport |
| // layer may not send the response back (either soap fault or result). |
| do |
| { |
| /* populate MessageData with transport information */ |
| m_pMsgData->m_Protocol = pStream->getProtocol (); |
| |
| if (AXIS_SUCCESS != m_pDZ->setInputStream (pStream)) |
| { |
| nSoapVersion = m_pDZ->getVersion (); |
| nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion; |
| m_pSZ->setSoapVersion ((SOAP_VERSION) nSoapVersion); |
| |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR); |
| } |
| |
| const char *cService = pStream->getTransportProperty (SERVICE_URI); |
| if (!cService) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR); |
| } |
| AxisString service = (cService == NULL) ? "" : cService; |
| |
| if (service.empty ()) |
| { |
| nSoapVersion = m_pMsgData->m_pDZ->getVersion (); |
| nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion; |
| m_pSZ->setSoapVersion ((SOAP_VERSION) nSoapVersion); |
| |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_ACTION_EMTPY") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_ACTION_EMTPY); |
| } |
| |
| // if there are quotes remove them. |
| if (service.find ('\"') != string::npos) |
| { |
| service = service.substr (1, service.length () - 2); |
| } |
| |
| // get service description object from the WSDD Deployment object |
| m_pService = g_pWSDDDeployment->getService (service.c_str ()); |
| if (!m_pService) |
| { |
| nSoapVersion = m_pMsgData->m_pDZ->getVersion (); |
| nSoapVersion = (nSoapVersion == VERSION_LAST) ? SOAP_VER_1_2 : nSoapVersion; |
| m_pSZ->setSoapVersion ((SOAP_VERSION) nSoapVersion); |
| |
| logThrowExceptionWithData("AxisWsddException - CLIENT_WSDD_SERVICE_NOT_FOUND", service.c_str()) |
| |
| throw AxisWsddException (CLIENT_WSDD_SERVICE_NOT_FOUND, service.c_str()); |
| } |
| |
| m_CurrentProviderType = m_pService->getProvider (); |
| m_pSZ->setCurrentProviderType (m_CurrentProviderType); |
| m_pDZ->setCurrentProviderType (m_CurrentProviderType); |
| switch (m_CurrentProviderType) |
| { |
| case C_RPC_PROVIDER: |
| case CPP_RPC_PROVIDER: |
| m_pSZ->setStyle (RPC_ENCODED); |
| m_pDZ->setStyle (RPC_ENCODED); |
| break; |
| case C_DOC_PROVIDER: |
| case CPP_DOC_PROVIDER: |
| m_pSZ->setStyle (DOC_LITERAL); |
| m_pDZ->setStyle (DOC_LITERAL); |
| break; |
| case COM_PROVIDER: |
| // TODO: ?? |
| break; |
| default:; |
| // TODO: ?? |
| } |
| |
| /* Check for stream version in the request and decide whether we support |
| * it or not. If we do not support send a soapfault with version |
| * mismatch. |
| */ |
| nSoapVersion = m_pDZ->getVersion (); |
| if (m_pDZ->getStatus () != AXIS_SUCCESS) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_MESSAGE_INCOMPLETE") |
| |
| throw AxisSoapException (CLIENT_SOAP_MESSAGE_INCOMPLETE); |
| } |
| |
| if (nSoapVersion == VERSION_LAST) // version not supported |
| { |
| m_pSZ->setSoapVersion (SOAP_VER_1_2); |
| |
| logThrowException("AxisSoapException - SOAP_VERSION_MISMATCH") |
| |
| throw AxisSoapException (SOAP_VERSION_MISMATCH); |
| } |
| |
| /* Set Soap version in the Serializer and the envelope */ |
| if (AXIS_SUCCESS != m_pSZ->setSoapVersion ((SOAP_VERSION) nSoapVersion)) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR); |
| } |
| |
| /* Get the operation name from transport information Ex: from |
| * SOAPAction header |
| */ |
| if (AXIS_SUCCESS != m_pDZ->getHeader ()) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR); |
| } |
| if (AXIS_SUCCESS != m_pDZ->getBody ()) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR); |
| } |
| |
| AxisString sOperation = m_pDZ->getMethodNameToInvoke (); |
| |
| if (sOperation.empty ()) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_NO_SOAP_METHOD") |
| |
| throw AxisSoapException (CLIENT_SOAP_NO_SOAP_METHOD); |
| } |
| /* remove any quotes in the operation name */ |
| if (sOperation.rfind ('\"') != string::npos) |
| { |
| sOperation = sOperation.substr (0, sOperation.length () - 1); |
| } |
| |
| AxisString operationToInvoke = sOperation; |
| |
| m_pMsgData->setOperationName (operationToInvoke.c_str ()); |
| |
| if (m_pService->isAllowedMethod (operationToInvoke.c_str ())) |
| { |
| /* load actual web service handler */ |
| if (AXIS_SUCCESS != g_pHandlerPool->getWebService (&m_pWebService, sSessionId, m_pService)) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_COULD_NOT_LOAD_SRV") |
| |
| throw AxisEngineException(SERVER_ENGINE_COULD_NOT_LOAD_SRV); |
| } |
| |
| /* Check whether the provider type in the wsdd matchs the service's |
| * binding style |
| */ |
| AXIS_BINDING_STYLE nBindingStyle = RPC_ENCODED; |
| if (0 != m_pWebService->_functions) |
| /* C service */ |
| { |
| nBindingStyle = m_pWebService->_functions->getBindingStyle (m_pWebService->_object); |
| } |
| else if (0 != m_pWebService->_object) |
| { |
| nBindingStyle = ((WrapperClassHandler *)m_pWebService->_object)->getBindingStyle (); |
| } |
| |
| if (m_pSZ->getStyle () != nBindingStyle) |
| { |
| logThrowException("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR); |
| } |
| } |
| else |
| { |
| logThrowException("AxisWsddException - CLIENT_WSDD_METHOD_NOT_ALLOWED") |
| |
| throw AxisWsddException (CLIENT_WSDD_METHOD_NOT_ALLOWED); |
| } |
| |
| // Get Global and Transport Handlers |
| if (AXIS_SUCCESS != (Status = initializeHandlers (sSessionId,pStream->getProtocol()))) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_COULD_NOT_LOAD_HDL") |
| |
| throw AxisEngineException (SERVER_ENGINE_COULD_NOT_LOAD_HDL); |
| } |
| |
| // Get Service specific Handlers from the pool if configured any |
| if (AXIS_SUCCESS != (Status = g_pHandlerPool->getRequestFlowHandlerChain (&m_pSReqFChain,sSessionId,m_pService))) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_COULD_NOT_LOAD_HDL") |
| |
| throw AxisEngineException (SERVER_ENGINE_COULD_NOT_LOAD_HDL); |
| } |
| |
| if (AXIS_SUCCESS != (Status = g_pHandlerPool->getResponseFlowHandlerChain (&m_pSResFChain,sSessionId,m_pService))) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_COULD_NOT_LOAD_HDL") |
| |
| throw AxisEngineException (SERVER_ENGINE_COULD_NOT_LOAD_HDL); |
| } |
| |
| // Invoke all handlers |
| Status = invoke (m_pMsgData); |
| } |
| while (0); |
| |
| if (AXIS_SUCCESS != m_pDZ->flushInputStream ()) |
| { |
| } |
| |
| // Get any header blocks unprocessed (left) in the Deserializer and add them |
| // to the Serializer. They may be headers targetted to next soap processors. |
| HeaderBlock *pHderBlk = NULL; |
| while (true) |
| { |
| pHderBlk = m_pDZ->getHeaderBlock (); |
| if (pHderBlk) |
| m_pSZ->addHeaderBlock (pHderBlk); |
| else |
| break; |
| } |
| m_pSZ->setOutputStream (pStream); |
| |
| // Pool back the handlers and services |
| releaseHandlers (pStream); |
| |
| //todo |
| /* An exception derived from exception which is not handled will be |
| * handled here. You can call a method in AxisModule which may unload |
| * the ServerAxisEngine from the webserver and report the error. You can |
| * also write this in a logfile specific to axis. |
| */ |
| } |
| catch (AxisException & e) |
| { |
| // An exception which is not handled will be handled here. |
| int iExceptionCode = e.getExceptionCode (); |
| if (AXISC_SERVICE_THROWN_EXCEPTION == iExceptionCode) |
| { |
| // Writes the SoapMessage in which soap body contains only Fault |
| m_pSZ->setOutputStream (pStream); |
| releaseHandlers (pStream); |
| return AXIS_SUCCESS; |
| } |
| else |
| { |
| /* An exception has occurred inside Axis C++ engine.(not in a |
| * webservice or handler). Later we handle this by coming back in here |
| * and serialising the fault out |
| */ |
| throw e; |
| } |
| } |
| catch (exception& e) |
| { |
| e = e; |
| logExitWithReturnCode(SERVER_UNKNOWN_ERROR) |
| |
| return SERVER_UNKNOWN_ERROR; |
| } |
| catch (...) |
| { |
| logExitWithReturnCode(SERVER_UNKNOWN_ERROR) |
| |
| return SERVER_UNKNOWN_ERROR; |
| } |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int ServerAxisEngine:: |
| invoke (MessageData * pMsg) |
| { |
| logEntryEngine("ServerAxisEngine::invoke") |
| |
| enum AE_LEVEL { AE_START = 1, AE_TRH, AE_GLH, AE_SERH, AE_SERV }; |
| int Status = AXIS_FAIL; |
| int level = AE_START; |
| do |
| { |
| // Invoke transport request handlers |
| if (m_pTReqFChain) |
| if (AXIS_SUCCESS != (Status = m_pTReqFChain->invoke (pMsg))) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_HANDLER_FAILED") |
| |
| throw AxisEngineException (SERVER_ENGINE_HANDLER_FAILED); |
| } |
| |
| level++; // AE_TRH |
| // Invoke global request handlers |
| if (m_pGReqFChain) |
| if (AXIS_SUCCESS != (Status = m_pGReqFChain->invoke (pMsg))) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_HANDLER_FAILED") |
| |
| throw AxisEngineException (SERVER_ENGINE_HANDLER_FAILED); |
| } |
| |
| level++; // AE_GLH |
| // Invoke service specific request handlers |
| if (m_pSReqFChain) |
| if (AXIS_SUCCESS != (Status = m_pSReqFChain->invoke (pMsg))) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_HANDLER_FAILED") |
| |
| throw AxisEngineException (SERVER_ENGINE_HANDLER_FAILED); |
| } |
| |
| level++; // AE_SERH |
| |
| /* |
| * Before processing the soap body check whether there is any header |
| * blocks with mustUnderstand attribute left unprocessed in the |
| * Deserializer. If so return a soap fault. |
| */ |
| if (m_pDZ->isAnyMustUnderstandHeadersLeft ()) |
| { |
| logThrowException("AxisSoapException - SOAP_MUST_UNDERSTAND") |
| |
| throw AxisSoapException (SOAP_MUST_UNDERSTAND); |
| } |
| |
| // Call actual web service handler |
| if (m_pWebService) |
| { |
| if (0 != m_pWebService->_functions) |
| /* C web service */ |
| { |
| // Disable C support |
| //IMessageData_C cMC = { 0, 0 }; |
| //cMC._object = pMsg; |
| //cMC._functions = &IMessageData::ms_VFtable; |
| //Status = m_pWebService->_functions->invoke (m_pWebService-> |
| // _object, &cMC); |
| } |
| else if (0 != m_pWebService->_object) |
| Status = ((WrapperClassHandler *) m_pWebService->_object)->invoke (pMsg); |
| else |
| Status = AXIS_FAIL; |
| |
| if (AXIS_SUCCESS != Status) |
| { |
| logThrowException("AxisEngineException - SERVER_ENGINE_WEBSERVICE_FAILED") |
| |
| throw AxisEngineException (SERVER_ENGINE_WEBSERVICE_FAILED); |
| } |
| } |
| level++; // AE_SERV |
| } |
| while (0); |
| |
| pMsg->setPastPivotState (true); |
| |
| /* |
| * The case clauses in this switch statement have no breaks. |
| * Hence, if Everything up to web service invocation was successful |
| * then all response handlers are invoked. If there was a failure |
| * at some point the response handlers from that point onwards |
| * are invoked. |
| */ |
| switch (level) |
| { |
| case AE_SERV: // Everything Success. |
| Status = AXIS_SUCCESS; |
| // no break; |
| case AE_SERH: // Actual web service handler has failed |
| // Invoke web service specific response handlers |
| if (m_pSResFChain) |
| m_pSResFChain->invoke (pMsg); |
| // no break; |
| case AE_GLH: // web service specific handlers have failed |
| // invoke global response handlers |
| if (m_pGResFChain) |
| m_pGResFChain->invoke (pMsg); |
| // no break; |
| case AE_TRH: // Global handlers have failed |
| if (m_pTResFChain) |
| m_pTResFChain->invoke (pMsg); |
| // no break; |
| case AE_START:; // Transport handlers have failed |
| }; |
| |
| logExitWithReturnCode(Status) |
| |
| return Status; |
| } |
| |
| void ServerAxisEngine:: |
| onFault (MessageData * pMsg) |
| { |
| logEntryEngine("ServerAxisEngine::onFault") |
| |
| logExit() |
| } |
| |
| int ServerAxisEngine:: |
| setFaultOutputStream (int iFaultCode, SOAPTransport * pStream) |
| { |
| logEntryEngine("ServerAxisEngine::setFaultOutputStream") |
| |
| string sMessage = AxisException::getMessageForExceptionCode(iFaultCode); |
| SoapFault *pObjSoapFault = SoapFault::getSoapFault (iFaultCode); |
| pObjSoapFault->setFaultDetail (sMessage.c_str ()); |
| m_pSZ->setSoapFault (pObjSoapFault); |
| m_pSZ->setOutputStream (pStream); |
| releaseHandlers (pStream); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int ServerAxisEngine:: |
| setFaultOutputStream (AxisException iFault, SOAPTransport * pStream) |
| { |
| logEntryEngine("ServerAxisEngine::setFaultOutputStream") |
| |
| SoapFault *pObjSoapFault = SoapFault::getSoapFault (iFault.getExceptionCode()); |
| pObjSoapFault->setFaultDetail (iFault.what()); |
| m_pSZ->setSoapFault (pObjSoapFault); |
| m_pSZ->setOutputStream (pStream); |
| releaseHandlers (pStream); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| int ServerAxisEngine:: |
| releaseHandlers (SOAPTransport * pStream) |
| { |
| logEntryEngine("ServerAxisEngine::releaseHandlers") |
| |
| string sSessionId = pStream->getSessionId (); |
| // Pool back the Service specific handlers |
| if (m_pSReqFChain) |
| g_pHandlerPool->poolHandlerChain (m_pSReqFChain, sSessionId); |
| |
| if (m_pSResFChain) |
| g_pHandlerPool->poolHandlerChain (m_pSResFChain, sSessionId); |
| |
| /* Pool back the Global and Transport handlers |
| * UnInitializeHandlers(sSessionId, stream->trtype); |
| * Pool back the webservice |
| */ |
| if (m_pWebService) |
| g_pHandlerPool->poolWebService (sSessionId, m_pWebService, m_pService); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| AXIS_CPP_NAMESPACE_END |
