| /* -*- C++ -*- */ |
| /* |
| * 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 Sanjaya Sinharage (sanjayasing@opensource.lk) |
| * @author Susantha Kumara (skumara@virtusa.com) |
| * @author Samisa Abeysinghe (sabeysinghe@virtusa.com) |
| */ |
| |
| // !!! This include file must be first thing in file !!! |
| #include "../platforms/PlatformAutoSense.hpp" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| |
| #include <string> |
| #include <map> |
| #include <iostream> |
| |
| #include <axis/Axis.hpp> |
| |
| #ifdef AXIS_CLIENT_LIB |
| #include <axis/client/Call.hpp> |
| #include "AxisEngine.h" |
| #else |
| #include "server/ServerAxisEngine.h" |
| #endif |
| |
| #include <axis/AxisUserAPI.hpp> |
| |
| #include "../soap/SoapFault.h" |
| #include "../soap/URIMapping.h" |
| #include "../soap/SoapKeywordMapping.h" |
| #include "HandlerLoader.h" |
| #include "AppScopeHandlerPool.h" |
| #include "RequestScopeHandlerPool.h" |
| #include "SessionScopeHandlerPool.h" |
| #include "HandlerPool.h" |
| #include "SerializerPool.h" |
| #include "DeserializerPool.h" |
| #include "../wsdd/WSDDDeployment.h" |
| #include "../common/AxisUtils.h" |
| #include "../common/AxisConfig.h" |
| #include "../wsdd/WSDDKeywords.h" |
| #include "SOAPTransportFactory.h" |
| #include "XMLParserFactory.h" |
| |
| #include "../common/AxisTrace.h" |
| |
| |
| AXIS_CPP_NAMESPACE_USE |
| |
| #define BYTESTOREAD 64 |
| // The relative location of the wsdl files hardcoded |
| #define WSDLDIRECTORY "/wsdls/" |
| |
| // Synchronized global variables. |
| HandlerLoader* g_pHandlerLoader; |
| AppScopeHandlerPool* g_pAppScopeHandlerPool; |
| RequestScopeHandlerPool* g_pRequestScopeHandlerPool; |
| SessionScopeHandlerPool* g_pSessionScopeHandlerPool; |
| DeserializerPool* g_pDeserializerPool; |
| SerializerPool* g_pSerializerPool; |
| HandlerPool* g_pHandlerPool; |
| bool g_isRunning; |
| |
| // Unsynchronized read-only global variables. |
| WSDDDeployment* g_pWSDDDeployment; |
| AxisConfig* g_pConfig; |
| |
| //Keeps track of how many times initialize_module/uninitialize_module was called |
| static volatile long g_uModuleInitialize = 0; |
| |
| |
| void ModuleInitialize () |
| { |
| // synchronized global variables. |
| g_pHandlerLoader = new HandlerLoader (); |
| g_pAppScopeHandlerPool = new AppScopeHandlerPool (); |
| g_pRequestScopeHandlerPool = new RequestScopeHandlerPool (); |
| g_pSessionScopeHandlerPool = new SessionScopeHandlerPool (); |
| g_pDeserializerPool = new DeserializerPool (); |
| g_pSerializerPool = new SerializerPool (); |
| g_pHandlerPool = new HandlerPool (); |
| // unsynchronized read-only global variables. |
| g_pWSDDDeployment = new WSDDDeployment (); |
| } |
| |
| void ModuleUnInitialize () |
| { |
| // synchronized global variables. |
| delete g_pAppScopeHandlerPool; |
| delete g_pRequestScopeHandlerPool; |
| delete g_pSessionScopeHandlerPool; |
| delete g_pDeserializerPool; |
| delete g_pSerializerPool; |
| delete g_pHandlerPool; |
| delete g_pHandlerLoader; |
| |
| // unsynchronized read-only global variables. |
| delete g_pWSDDDeployment; |
| delete g_pConfig; |
| |
| g_pConfig = NULL; |
| g_pWSDDDeployment = NULL; |
| } |
| |
| #ifndef AXIS_CLIENT_LIB |
| |
| STORAGE_CLASS_INFO int process_request(SOAPTransport* pStream) |
| { |
| int Status = AXIS_FAIL; |
| FILE* WsddFile = NULL; |
| char ReadBuffer[BYTESTOREAD]; |
| ReadBuffer[0] = '\0'; |
| |
| const WSDDServiceMap* pSrvMap = NULL; |
| WSDDServiceMap::const_iterator iter; |
| WSDDService* pService = NULL; |
| |
| /* If there is no transport object provided */ |
| if (!pStream) |
| return AXIS_FAIL; |
| |
| switch (pStream->getProtocol()) |
| { |
| case APTHTTP1_1: |
| case APTHTTP1_0: |
| // Handle the POST method |
| if (AXIS_HTTP_POST == pStream->getSubProtocol()) |
| { |
| AxisEngine *engine = new ServerAxisEngine (); |
| if (engine) |
| { |
| if (AXIS_SUCCESS == engine->initialize ()) |
| { |
| try |
| { |
| Status = engine->process(pStream); |
| if (AXIS_SUCCESS == Status) |
| pStream->flushOutput(); |
| else |
| { |
| ServerAxisEngine* pObjTempServer = (ServerAxisEngine*) engine; |
| pObjTempServer->setFaultOutputStream(Status, pStream); |
| pStream->flushOutput(); |
| pObjTempServer = NULL; |
| Status = AXIS_SUCCESS; |
| } |
| } |
| catch(AxisException& e) |
| { |
| ServerAxisEngine* pObjTempServer = (ServerAxisEngine*) engine; |
| pObjTempServer->setFaultOutputStream(e, pStream); |
| pStream->flushOutput(); |
| pObjTempServer = NULL; |
| Status = AXIS_SUCCESS; |
| } |
| } |
| delete engine; |
| } |
| } |
| else if (AXIS_HTTP_GET == pStream->getSubProtocol()) |
| { |
| // get the uri path |
| // i.e "/abc/xyz/" part of http://somehost/abc/xyz/ |
| string sUriWOAxis = pStream->getTransportProperty(SERVICE_URI); |
| string sServiceName; |
| bool bNoExt = true; |
| if (sUriWOAxis == "/") |
| { |
| bNoExt = false; |
| sUriWOAxis = ""; |
| } |
| |
| if (sUriWOAxis.empty ()) |
| { |
| pSrvMap = g_pWSDDDeployment->getWSDDServiceMap (); |
| if (!pSrvMap) |
| { |
| // Samisa: the string continuation lines in the following |
| // code segments should *NOT* be indented |
| // in order to make sure the HTML is indented properly. |
| pStream->sendBytes("<html> \n\ |
| \t<head>\n\ |
| \t\t<title>Welcome to Axis C++</title>\n\ |
| \t</head>\n\ |
| \t<body>\n\ |
| \t\t<h1 align=\"center\">Welcome to Axis C++</h1>\n\ |
| \t\t<br>\n\ |
| \t\t<h2>Deployment Descriptor Not Found</h2>\n\ |
| \t\t<br>\n\ |
| \t</body>\n\ |
| </html>\n", NULL); |
| return AXIS_FAIL; |
| } |
| pStream->sendBytes("<html>\n\ |
| \t<head>\n\ |
| \t\t<title>Welcome to Axis C++</title>\n\ |
| \t</head>\n\ |
| \t<body>\n\ |
| \t\t<h1 align=\"center\">Welcome to Axis C++</h1>\n\ |
| \t\t<br>\n\ |
| \t\t<h2 align=\"center\">List of Deployed Web services</h2>\n\ |
| \t\t<br>\n\ |
| \t\t<table width=\"100%\" border=1 align=\"center\">\n\ |
| \t\t\t<tbody>\n", NULL); |
| |
| pStream->sendBytes |
| ("\t\t\t\t<tr>\n\ |
| \t\t\t\t\t<td width=\"20%\"><b>Web Service</b></td>\n\ |
| \t\t\t\t\t<td width=\"10%\" align=\"left\"><b>WSDL</b></td>\n\ |
| \t\t\t\t\t<td width=\"70%\"><b>Description</b></td>\n\ |
| \t\t\t\t</tr>\n", NULL); |
| for (iter = pSrvMap->begin (); iter != pSrvMap->end (); |
| iter++) |
| { |
| pService = (*iter).second; |
| pStream->sendBytes("\t\t\t\t<tr>\n\ |
| \t\t\t\t\t<td width=\"20%\">", NULL); |
| pStream->sendBytes((char*) pService-> |
| getServiceName (), NULL); |
| pStream->sendBytes |
| ("</td>\n\ |
| \t\t\t\t\t<td width=\"10%\" align=\"left\">\n\ |
| \t\t\t\t\t\t<a href=\"./", |
| NULL); |
| //if (bNoExt) pStream->sendBytes("axis/", NULL); |
| pStream->sendBytes((char*) pService-> |
| getServiceName (), NULL); |
| pStream->sendBytes("?wsdl", NULL); |
| pStream->sendBytes("\">wsdl</a>\n\ |
| \t\t\t\t\t</td>\n\ |
| \t\t\t\t\t<td width=\"70%\">", NULL); |
| pStream->sendBytes((char*) pService-> |
| getDescription (), NULL); |
| pStream->sendBytes("</td>\n\ |
| \t\t\t\t</tr>\n", NULL); |
| } |
| pStream->sendBytes("\t\t\t</tbody>\n\ |
| \t\t</table>\n", NULL); |
| pStream->sendBytes |
| ("\t\t<br><p align=\"center\">Copyright 2001-2003 The Apache Software Foundation<br></p>\n\t</body>\n</html>\n", NULL); |
| Status = AXIS_SUCCESS; |
| } |
| else |
| { |
| sServiceName = g_pConfig->getAxisConfProperty(AXCONF_AXISHOME); |
| sServiceName += WSDLDIRECTORY + sUriWOAxis + ".wsdl"; |
| // Check whether wsdl file is available |
| if ((WsddFile = fopen (sServiceName.c_str (), "r")) == NULL) |
| { |
| pStream->sendBytes("<h3>Url not available</h3>", NULL); |
| Status = AXIS_SUCCESS; |
| } |
| else |
| { |
| int charcount = 0; |
| while ((charcount = fread (ReadBuffer, 1, BYTESTOREAD - 1, WsddFile)) != 0) |
| { |
| *(ReadBuffer + charcount) = '\0'; |
| pStream->sendBytes(ReadBuffer, NULL); |
| } |
| Status = AXIS_SUCCESS; |
| fclose (WsddFile); |
| } |
| } |
| } |
| |
| break; |
| |
| default: |
| pStream->sendBytes("Unknown Protocol", NULL); |
| break; |
| } |
| |
| return Status; |
| } |
| |
| #endif |
| |
| #ifdef WIN32 |
| |
| static CRITICAL_SECTION g_initializationCriticalSection; |
| static BOOL g_bCSInitialized = (InitializeCriticalSection(&g_initializationCriticalSection), TRUE); |
| static void start_initializing() |
| { |
| EnterCriticalSection(&g_initializationCriticalSection); |
| } |
| static void done_initializing() |
| { |
| LeaveCriticalSection(&g_initializationCriticalSection); |
| } |
| |
| #else |
| |
| #include <pthread.h> |
| static pthread_mutex_t initializingMutex = PTHREAD_MUTEX_INITIALIZER; |
| |
| static void start_initializing() |
| { |
| pthread_mutex_lock(&initializingMutex); |
| } |
| |
| static void done_initializing() |
| { |
| pthread_mutex_unlock(&initializingMutex); |
| } |
| |
| #endif |
| |
| |
| |
| extern "C" { |
| STORAGE_CLASS_INFO |
| int initialize_module (int bServer) |
| { |
| start_initializing(); |
| |
| int status = AXIS_SUCCESS; |
| |
| try |
| { |
| if (g_uModuleInitialize == 0) |
| { |
| // Read config file and enable trace....this should be first thing that is done!!! |
| // Read from the configuration file |
| if( g_pConfig != NULL) |
| g_pConfig = new AxisConfig( g_pConfig); |
| else |
| g_pConfig = new AxisConfig(); |
| |
| status = g_pConfig->readConfFile (); |
| if (status == AXIS_SUCCESS) |
| { |
| // One can also start trace via Axis::startTrace(). If that has been done, |
| // ignore the config file. |
| if (!AxisTrace::isLoggingEnabled()) |
| { |
| AxisTrace::setLogFilter(g_pConfig->getAxisConfProperty(AXCONF_LOGFILTER)); |
| |
| if (bServer) |
| AxisTrace::startTrace(g_pConfig->getAxisConfProperty(AXCONF_LOGPATH)); |
| else |
| AxisTrace::startTrace(g_pConfig->getAxisConfProperty(AXCONF_CLIENTLOGPATH)); |
| } |
| |
| string configProperties = g_pConfig->toString(); |
| AxisTrace::writeTrace(configProperties.c_str(), configProperties.length()); |
| } |
| |
| // The entry log must start here - may revisit so as to start earlier. |
| logEntryEngine("initialize_module") |
| |
| // order of these initialization method invocation should not be changed |
| AxisEngine::m_bServer = bServer; |
| AxisUtils::initialize (); |
| WSDDKeywords::initialize (); |
| SoapKeywordMapping::initialize (); |
| TypeMapping::initialize (); |
| URIMapping::initialize (); |
| SoapFault::initialize (); |
| ModuleInitialize (); |
| |
| if (bServer) // no client side wsdd processing at the moment |
| { |
| if (status == AXIS_SUCCESS) |
| { |
| try |
| { |
| XMLParserFactory::initialize(); |
| } |
| catch (AxisException& e) |
| { |
| logRethrowException() |
| |
| throw AxisEngineException(e.getExceptionCode(), e.what()); |
| } |
| |
| char *pWsddPath = g_pConfig->getAxisConfProperty(AXCONF_WSDDFILEPATH); |
| |
| try |
| { |
| if (AXIS_SUCCESS != g_pWSDDDeployment->loadWSDD (pWsddPath)) |
| status = AXIS_FAIL; |
| } |
| catch (AxisException& e) |
| { |
| logRethrowException() |
| |
| throw AxisEngineException(e.getExceptionCode(), e.what()); |
| } |
| } |
| else |
| status = AXIS_FAIL; |
| } |
| else if (bServer == 0) // client side module initialization |
| { |
| if (status == AXIS_SUCCESS) |
| { |
| XMLParserFactory::initialize(); |
| SOAPTransportFactory::initialize(); |
| |
| char * pClientWsddPath = g_pConfig->getAxisConfProperty(AXCONF_CLIENTWSDDFILEPATH); |
| |
| // May be there is no client side handlers configured. So may not have CLIENTWSDDFILEPATH entry in axiscpp.conf |
| if (pClientWsddPath) |
| if (AXIS_SUCCESS != g_pWSDDDeployment->loadWSDD (pClientWsddPath)) |
| status = AXIS_FAIL; |
| } |
| } |
| else |
| { |
| /* Ok if we can't read config file */ |
| status = AXIS_SUCCESS; |
| } |
| |
| g_isRunning = true; |
| |
| logExitWithReturnCode(status) |
| } |
| else if (AxisEngine::m_bServer != bServer) |
| { |
| throw AxisEngineException(SERVER_ENGINE_EXCEPTION); |
| } |
| } |
| catch (...) |
| { |
| done_initializing(); |
| throw; |
| } |
| |
| ++g_uModuleInitialize; |
| done_initializing(); |
| |
| return status; |
| } |
| } |
| |
| |
| extern "C" { |
| STORAGE_CLASS_INFO |
| int uninitialize_module () |
| { |
| logEntryEngine("uninitialize_module") |
| |
| start_initializing(); |
| |
| try |
| { |
| if (g_uModuleInitialize > 0) |
| { |
| if (--g_uModuleInitialize == 0) |
| { |
| g_isRunning = false; |
| TypeMapping::uninitialize(); |
| URIMapping::uninitialize(); |
| if (!AxisEngine::m_bServer) |
| SOAPTransportFactory::uninitialize(); |
| ModuleUnInitialize(); |
| SoapKeywordMapping::uninitialize(); |
| XMLParserFactory::uninitialize(); |
| } |
| } |
| } |
| catch (...) |
| { |
| done_initializing(); |
| |
| logRethrowException() |
| |
| throw; |
| } |
| |
| done_initializing(); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| } |
| |
| |
| void Ax_Sleep (int nTime) |
| { |
| PLATFORM_SLEEP(0); |
| } |
| |
| |
| // Axis class method implementations |
| |
| void Axis::initialize(bool bIsServer) |
| { |
| logEntryEngine("Axis::initialize") |
| |
| initialize_module(bIsServer); |
| |
| logExit() |
| } |
| |
| void Axis::terminate() |
| { |
| logEntryEngine("Axis::terminate") |
| |
| uninitialize_module(); |
| |
| logExit() |
| } |
| |
| void Axis::AxisDelete(void *pValue, XSDTYPE type) |
| { |
| logEntryEngine("Axis::AxisDelete") |
| |
| if (pValue == NULL) |
| return; |
| |
| switch (type) |
| { |
| case XSD_STRING: |
| { |
| delete [] (xsd__string) pValue; |
| break; |
| } |
| case XSD_NORMALIZEDSTRING: |
| { |
| delete [] (xsd__normalizedString) pValue; |
| break; |
| } |
| case XSD_FLOAT: |
| { |
| delete (xsd__float*) pValue; |
| break; |
| } |
| case XSD_DECIMAL: |
| { |
| delete (xsd__decimal*) pValue; |
| break; |
| } |
| case XSD_NONPOSITIVEINTEGER: |
| { |
| delete (xsd__nonPositiveInteger*) pValue; |
| break; |
| } |
| case XSD_NEGATIVEINTEGER: |
| { |
| delete (xsd__negativeInteger*) pValue; |
| break; |
| } |
| case XSD_INTEGER: |
| { |
| delete (xsd__integer*) pValue; |
| break; |
| } |
| case XSD_LONG: |
| { |
| delete (xsd__long*) pValue; |
| break; |
| } |
| case XSD_INT: |
| { |
| delete (xsd__int*) pValue; |
| break; |
| } |
| case XSD_SHORT: |
| { |
| delete (xsd__short*) pValue; |
| break; |
| } |
| case XSD_BYTE: |
| { |
| delete (xsd__byte*) pValue; |
| break; |
| } |
| case XSD_NONNEGATIVEINTEGER: |
| { |
| delete (xsd__nonNegativeInteger*) pValue; |
| break; |
| } |
| case XSD_UNSIGNEDLONG: |
| { |
| delete (xsd__unsignedLong*) pValue; |
| break; |
| } |
| case XSD_UNSIGNEDINT: |
| { |
| delete (xsd__unsignedInt*) pValue; |
| break; |
| } |
| case XSD_UNSIGNEDSHORT: |
| { |
| delete (xsd__unsignedShort*) pValue; |
| break; |
| } |
| case XSD_UNSIGNEDBYTE: |
| { |
| delete (xsd__unsignedByte*) pValue; |
| break; |
| } |
| case XSD_POSITIVEINTEGER: |
| { |
| delete (xsd__positiveInteger*) pValue; |
| break; |
| } |
| case XSD_DOUBLE: |
| { |
| delete (xsd__double*) pValue; |
| break; |
| } |
| case XSD_DURATION: |
| { |
| delete (xsd__duration*) pValue; |
| break; |
| } |
| case XSD_DATETIME: |
| { |
| delete (xsd__dateTime*) pValue; |
| break; |
| } |
| case XSD_TIME: |
| { |
| delete (xsd__time*) pValue; |
| break; |
| } |
| case XSD_DATE: |
| { |
| delete (xsd__date*) pValue; |
| break; |
| } |
| case XSD_GYEARMONTH: |
| { |
| delete (xsd__gYearMonth*) pValue; |
| break; |
| } |
| case XSD_GYEAR: |
| { |
| delete (xsd__gYear*) pValue; |
| break; |
| } |
| case XSD_GMONTHDAY: |
| { |
| delete (xsd__gMonthDay*) pValue; |
| break; |
| } |
| case XSD_GDAY: |
| { |
| delete (xsd__gDay*) pValue; |
| break; |
| } |
| case XSD_GMONTH: |
| { |
| delete (xsd__gMonth*) pValue; |
| break; |
| } |
| case XSD_TOKEN: |
| { |
| delete [] (xsd__token) pValue; |
| break; |
| } |
| case XSD_LANGUAGE: |
| { |
| delete [] (xsd__language) pValue; |
| break; |
| } |
| case XSD_NAME: |
| { |
| delete [] (xsd__Name) pValue; |
| break; |
| } |
| case XSD_NCNAME: |
| { |
| delete [] (xsd__NCName) pValue; |
| break; |
| } |
| case XSD_ID: |
| { |
| delete [] (xsd__ID) pValue; |
| break; |
| } |
| case XSD_IDREF: |
| { |
| delete [] (xsd__IDREF) pValue; |
| break; |
| } |
| case XSD_IDREFS: |
| { |
| delete [] (xsd__IDREFS) pValue; |
| break; |
| } |
| case XSD_ENTITY: |
| { |
| delete [] (xsd__ENTITY) pValue; |
| break; |
| } |
| case XSD_ENTITIES: |
| { |
| delete [] (xsd__ENTITIES) pValue; |
| break; |
| } |
| case XSD_NMTOKEN: |
| { |
| delete [] (xsd__NMTOKEN) pValue; |
| break; |
| } |
| case XSD_NMTOKENS: |
| { |
| delete [] (xsd__NMTOKENS) pValue; |
| break; |
| } |
| case XSD_BOOLEAN: |
| { |
| delete (xsd__boolean*) pValue; |
| break; |
| } |
| case XSD_BASE64BINARY: |
| { |
| delete (xsd__base64Binary*) pValue; |
| break; |
| } |
| case XSD_HEXBINARY: |
| { |
| delete (xsd__hexBinary*) pValue; |
| break; |
| } |
| case XSD_ANYURI: |
| { |
| delete [] (xsd__anyURI) pValue; |
| break; |
| } |
| case XSD_QNAME: |
| { |
| delete [] (xsd__QName) pValue; |
| break; |
| } |
| case XSD_NOTATION: |
| { |
| delete [] (xsd__NOTATION) pValue; |
| break; |
| } |
| case USER_TYPE: |
| // The USER_TYPE object should be cleared by the Application |
| break; |
| case XSD_ARRAY: |
| { |
| delete (Axis_Array*) pValue; |
| break; |
| } |
| case XSD_ANYTYPE: |
| { |
| delete [] (xsd__anyType) pValue; |
| break; |
| } |
| case XSD_ANY: |
| case ATTACHMENT: |
| case XSD_UNKNOWN: |
| default: |
| ; |
| } |
| |
| logExit() |
| } |
| |
| bool Axis::isRunning() |
| { |
| return g_isRunning; |
| } |
| |
| void Axis::stopAxis() |
| { |
| logEntryEngine("Axis::stopAxis") |
| |
| start_initializing(); |
| g_isRunning = false; |
| done_initializing(); |
| |
| logExit() |
| } |
| |
| int Axis:: |
| startTrace(const char* logFilePath, const char *logFilter) |
| { |
| AxisTrace::setLogFilter(logFilter); |
| return AxisTrace::startTrace(logFilePath); |
| } |
| |
| void Axis:: |
| stopTrace() |
| { |
| AxisTrace::stopTrace(); |
| } |
| |
| void Axis:: |
| writeTrace(AXIS_TRACE_TYPE type, const char* functionName, const char * fmt, ...) |
| { |
| // If logging is not enabled, just return. |
| if (!AxisTrace::isLoggingEnabled() || !AxisTrace::isStubLoggingEnabled()) |
| return; |
| |
| // Construct final formatter |
| string myfmt; |
| string blank = " "; |
| |
| char *traceType = TRACE_TYPE_DEBUG; |
| if (type == AXIS_TRACE_TYPE_ENTRY) |
| traceType = TRACE_TYPE_ENTRY; |
| else if (type == AXIS_TRACE_TYPE_EXIT) |
| traceType = TRACE_TYPE_EXIT; |
| else if (type == AXIS_TRACE_TYPE_EXCEPTION) |
| traceType = TRACE_TYPE_EXCEPT; |
| |
| if (NULL == fmt) |
| fmt = ""; |
| myfmt += TRACE_COMPONENT_STUB + blank; |
| myfmt += traceType + blank; |
| myfmt += functionName; |
| myfmt += "(): "; |
| myfmt += fmt; |
| |
| va_list vargs; |
| va_start(vargs,fmt); |
| AxisTrace::writeTrace(myfmt.c_str(), vargs); |
| va_end(vargs); |
| } |
