// Remove any dialogs in the terminated state.
// This operates only on the parsed dialogs in mXmlDialogs, used to generate
// the consolidated state. The RFC 4662 events are not affected, but
// presumably the resource is not allowing terminated dialogs to accumulate
// in the events it sends.
void ResourceInstance::purgeTerminatedDialogs()
{
OsSysLog::add(FAC_RLS, PRI_DEBUG,
"ResourceInstance::purgeTerminatedDialogs mInstanceName = '%s'",
mInstanceName.data());
// Iterate through all the <dialog> elements.
UtlHashMapIterator itor(mXmlDialogs);
UtlContainable* id;
while ((id = itor()))
{
// Get the <state> element content.
UtlVoidPtr* p = dynamic_cast <UtlVoidPtr*> (itor.value());
TiXmlElement* dialog_element =
static_cast <TiXmlElement*> (p->getValue());
TiXmlNode* state_node = dialog_element->FirstChild("state");
UtlString state;
textContentShallow(state, state_node);
if (state.compareTo("terminated") == 0)
{
// This dialog was terminated. Remove it.
delete dialog_element;
mXmlDialogs.destroy(id);
}
}
// Note that we do not have to publish this change, as the deletion
// of these dialogs does not have to be sent to the subscribers
// quickly.
}
UtlBoolean SipUdpServer::getStunAddress(UtlString* pIpAddress, int* pPort,
const char* szLocalIp)
{
UtlBoolean bRet = false;
OsStunDatagramSocket* pSocket = NULL;
UtlVoidPtr* pSocketContainer = NULL;
if (szLocalIp)
{
UtlString localIpKey(szLocalIp);
pSocketContainer = (UtlVoidPtr*)this->mServerSocketMap.findValue(&localIpKey);
if (pSocketContainer)
{
pSocket = (OsStunDatagramSocket*)pSocketContainer->getValue();
}
}
else
{
// just use the default Socket in our collection
UtlString defaultIpKey(mDefaultIp);
pSocketContainer = (UtlVoidPtr*)mServerSocketMap.findValue(&defaultIpKey);
if (pSocketContainer != NULL )
{
pSocket = (OsStunDatagramSocket*)pSocketContainer->getValue();
}
}
if (pSocket)
{
bRet = pSocket->getExternalIp(pIpAddress, pPort) ;
}
return bRet;
}
UtlBoolean sipxIsCallInFocus()
{
UtlBoolean inFocus = false ;
if (gpCallHandleMap->lock())
{
UtlHashMapIterator iter(*gpCallHandleMap);
UtlInt* pIndex = NULL;
UtlVoidPtr* pObj = NULL;
SIPX_CALL hCall = 0 ;
while (pIndex = dynamic_cast<UtlInt*>( iter() ) )
{
pObj = dynamic_cast<UtlVoidPtr*>(gpCallHandleMap->findValue(pIndex));
SIPX_CALL_DATA* pData = NULL ;
if (pObj)
{
pData = (SIPX_CALL_DATA*) pObj->getValue() ;
if (pData->bInFocus)
{
inFocus = true ;
break ;
}
}
}
gpCallHandleMap->unlock() ;
}
return inFocus ;
}
// Dump the object's internal state.
void ResourceInstance::dumpState()
{
// indented 12
OsSysLog::add(FAC_RLS, PRI_INFO,
"\t ResourceInstance %p mInstanceName = '%s', "
"mSubscriptionState = '%s', mContentPresent = %d, mContent = '%s'",
this, mInstanceName.data(), mSubscriptionState.data(),
mContentPresent,
mContentPresent ? mContent.data() : "[invalid]");
UtlHashMapIterator itor(mXmlDialogs);
UtlString* dialog_id;
while ((dialog_id = dynamic_cast <UtlString*> (itor())))
{
UtlVoidPtr* p = dynamic_cast <UtlVoidPtr*> (itor.value());
TiXmlElement* dialog_element =
static_cast <TiXmlElement*> (p->getValue());
UtlString s;
TiXmlUtlStringWriter writer(&s);
writer <<*dialog_element;
OsSysLog::add(FAC_RLS, PRI_INFO,
"\t mXmlDialogs{'%s'} = '%s'",
dialog_id->data(), s.data());
}
}
const void* SipXHandleMap::removeHandle(SIPXHANDLE handle)
{
const void* pRC = NULL ;
if (lock())
{
releaseHandleRef(handle);
UtlInt* pCount = static_cast<UtlInt*>(mLockCountHash.findValue(&UtlInt(handle))) ;
if (pCount == NULL || pCount->getValue() < 1)
{
UtlInt key(handle) ;
UtlVoidPtr* pValue ;
pValue = (UtlVoidPtr*) findValue(&key) ;
if (pValue != NULL)
{
pRC = pValue->getValue() ;
destroy(&key) ;
}
if (pCount)
{
mLockCountHash.destroy(&UtlInt(handle));
}
}
unlock() ;
}
return pRC ;
}
// Report to all the notifiers in mStateChangeNotifiers a new event
// 'dialogEvent' for AOR 'contact'.
void SipDialogMonitor::notifyStateChange(UtlString& contact,
StateChangeNotifier::Status status)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange "
"AOR = '%s', status = %s",
contact.data(),
(status == StateChangeNotifier::ON_HOOK ? "ON_HOOK" :
status == StateChangeNotifier::OFF_HOOK ? "OFF_HOOK" :
"UNKNOWN"));
Url contactUrl(contact);
// Loop through the notifier list, reporting the status to the notifiers.
UtlHashMapIterator iterator(mStateChangeNotifiers);
UtlString* listUri;
UtlVoidPtr* container;
StateChangeNotifier* notifier;
while ((listUri = dynamic_cast <UtlString *> (iterator())))
{
container = dynamic_cast <UtlVoidPtr *> (mStateChangeNotifiers.findValue(listUri));
notifier = (StateChangeNotifier *) container->getValue();
// Report the status to the notifier.
notifier->setStatus(contactUrl, status);
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"SipDialogMonitor::notifyStateChange setting state to %d",
status);
}
}
// Destructor
SipUdpServer::~SipUdpServer()
{
waitUntilShutDown();
SipClient* pServer = NULL;
UtlHashMapIterator iterator(mServers);
UtlVoidPtr* pServerContainer = NULL;
UtlString* pKey = NULL;
while (pKey = (UtlString*)iterator())
{
pServerContainer = (UtlVoidPtr*)iterator.value();
if (pServerContainer)
{
pServer = (SipClient*)pServerContainer->getValue();
pServer->requestShutdown();
delete pServer;
}
}
mServers.destroyAll();
mServerPortMap.destroyAll();
mServerSocketMap.destroyAll();
}
UtlBoolean SipTlsServer::startListener()
{
UtlBoolean bRet(FALSE);
# ifdef TEST_PRINT
osPrintf("SIP Server binding to port %d\n", serverPort);
# endif
// iterate over the SipServerBroker map and call start
UtlHashMapIterator iterator(mServerBrokers);
UtlVoidPtr* pBrokerContainer = NULL;
SipServerBroker* pBroker = NULL;
UtlString* pKey = NULL;
while(pKey = (UtlString*)iterator())
{
pBrokerContainer = (UtlVoidPtr*) iterator.value();
if (pBrokerContainer)
{
pBroker = (SipServerBroker*)pBrokerContainer->getValue();
if (pBroker)
{
pBroker->start();
bRet = TRUE;
}
}
}
return bRet;
}
void SipUdpServer::printStatus()
{
SipClient* pServer = NULL;
UtlHashMapIterator iterator(mServers);
UtlVoidPtr* pServerContainer = NULL;
UtlString* pKey = NULL;
while (pKey = (UtlString*)iterator())
{
pServerContainer = (UtlVoidPtr*) iterator.value();
if (pServerContainer)
{
pServer = (SipClient*)pServerContainer->getValue();
}
if (pServer)
{
UtlString clientNames;
long clientTouchedTime = pServer->getLastTouchedTime();
UtlBoolean clientOk = pServer->isOk();
pServer->getClientNames(clientNames);
osPrintf("UDP server %p last used: %ld ok: %d names: \n%s \n",
this, clientTouchedTime, clientOk, clientNames.data());
SipProtocolServerBase::printStatus();
}
}
}
// Destructor
SipTlsServer::~SipTlsServer()
{
waitUntilShutDown();
if (mpServerBrokerListener)
{
mpServerBrokerListener->requestShutdown();
delete mpServerBrokerListener;
}
{
SipServerBroker* pBroker = NULL;
UtlHashMapIterator iterator(this->mServerBrokers);
UtlVoidPtr* pBrokerContainer = NULL;
UtlString* pKey = NULL;
while (pKey = (UtlString*)iterator())
{
pBrokerContainer = (UtlVoidPtr*)iterator.value();
if (pBrokerContainer)
{
pBroker = (SipServerBroker*)pBrokerContainer->getValue();
if (pBroker)
{
pBroker->requestShutdown();
delete pBroker;
}
}
}
mServerBrokers.destroyAll();
}
/*
{
OsSocket* pSocket = NULL;
UtlHashMapIterator iterator(mServerSocketMap);
UtlVoidPtr* pSocketContainer = NULL;
UtlString* pKey = NULL;
while (pKey = (UtlString*)iterator())
{
pSocketContainer = (UtlVoidPtr*)iterator.value();
if (pSocketContainer)
{
pSocket = (OsSocket*)pSocketContainer->getValue();
if (pSocket)
{
delete pSocket;
}
}
}
mServerSocketMap.destroyAll();
}
*/
mServerSocketMap.destroyAll();
mServerPortMap.destroyAll();
}
UtlBoolean SipProtocolServerBase::startListener()
{
# ifdef TEST_PRINT
osPrintf("SIP Server binding to port %d\n", serverPort);
# endif
UtlHashMapIterator iter(mServerSocketMap);
UtlVoidPtr* pSocketContainer = NULL;
UtlString* pKey;
while ((pKey =(UtlString*)iter()))
{
OsSocket* pSocket = NULL;
SipClient* pServer = NULL;
UtlVoidPtr* pServerContainer = NULL;
UtlString localIp = *pKey;
pSocketContainer = (UtlVoidPtr*)iter.value();
if (pSocketContainer)
{
pSocket = (OsSocket*)pSocketContainer->getValue();
}
pServerContainer = (UtlVoidPtr*)mServers.findValue(&localIp);
if (!pServerContainer)
{
pServer = new SipClient(pSocket);
// This used to be done at the end of this else statement
// however there is a race and the userAgent must be set before
// starting this client. I think the race occurs if there is
// immediately an incoming message on the socket.
if(mSipUserAgent)
{
if (pServer)
{
pServer->setUserAgent(mSipUserAgent);
}
}
this->mServers.insertKeyAndValue(new UtlString(localIp), new UtlVoidPtr((void*)pServer));
pServer->start();
}
else
{
pServer = (SipClient*) pServerContainer->getValue();
if(mSipUserAgent)
{
if (pServer)
{
pServer->setUserAgent(mSipUserAgent);
}
}
}
}
return(TRUE);
}
void SipDialogMonitor::notifyStateChange(UtlString& contact, SipDialogEvent* dialogEvent)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange contact = %s",
contact.data());
// Loop through the notifier list
UtlHashMapIterator iterator(mStateChangeNotifiers);
UtlString* listUri;
UtlVoidPtr* container;
StateChangeNotifier* notifier;
Url contactUrl(contact);
mLock.acquire();
while (listUri = dynamic_cast <UtlString *> (iterator()))
{
container = dynamic_cast <UtlVoidPtr *> (mStateChangeNotifiers.findValue(listUri));
notifier = (StateChangeNotifier *) container->getValue();
if (dialogEvent->isEmpty())
{
notifier->setStatus(contactUrl, StateChangeNotifier::ON_HOOK);
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange dialog is empty, setting state to on hook");
}
else
{
Dialog* dialog = dialogEvent->getFirstDialog();
UtlString state, event, code;
dialog->getState(state, event, code);
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange dialog state = %s",
state.data());
if (state.compareTo(STATE_CONFIRMED) == 0)
{
notifier->setStatus(contactUrl, StateChangeNotifier::OFF_HOOK);
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange setting state to off hook");
}
else
{
if (state.compareTo(STATE_TERMINATED) == 0)
{
notifier->setStatus(contactUrl, StateChangeNotifier::ON_HOOK);
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange setting state to on hook");
}
else
{
notifier->setStatus(contactUrl, StateChangeNotifier::RINGING);
OsSysLog::add(FAC_SIP, PRI_DEBUG, "SipDialogMonitor::notifyStateChange setting state to ringing");
}
}
}
}
mLock.release();
}
void SipXHandleMap::dump()
{
UtlHashMapIterator itor(*this) ;
UtlInt* pKey ;
UtlVoidPtr* pValue ;
while ((pKey = (UtlInt*) itor()))
{
pValue = (UtlVoidPtr*) findValue(pKey) ;
printf("\tkey=%08X, value=%p\n", pKey->getValue(),
pValue ? pValue->getValue() : 0) ;
}
}
// Destroy the contents of mXmlDialogs.
void ResourceInstance::destroyXmlDialogs()
{
// First, follow through the UtlVoidPtr's to get pointers to the
// XML trees and delete them.
UtlHashMapIterator itor(mXmlDialogs);
UtlContainable* id;
while ((id = itor()))
{
UtlVoidPtr* p = dynamic_cast <UtlVoidPtr*> (itor.value());
delete static_cast <TiXmlElement*> (p->getValue());
}
// Now clear the hash map and its keys and the UtlVoidPtr's themselves.
mXmlDialogs.destroyAll();
}
void* OsLockingList::pop()
{
void* element = NULL;
// Lock before accessing the list
OsLock localLock(listMutex);
if (list.entries())
{
UtlVoidPtr* elementContainer = dynamic_cast<UtlVoidPtr*>(list.last());
list.removeReference(elementContainer);
element = (void*) elementContainer->getValue();
delete elementContainer;
}
return(element);
}
void SipUdpServer::shutdownListener()
{
SipClient* pServer = NULL;
UtlHashMapIterator iterator(mServers);
UtlVoidPtr* pServerContainer = NULL;
UtlString* pKey = NULL;
while (pKey = (UtlString*)iterator())
{
pServerContainer = (UtlVoidPtr*) iterator.value();
pServer = (SipClient*)pServerContainer->getValue();
if (pServer)
{
pServer->requestShutdown();
}
}
}
void* OsLockingList::remove(int iteratorHandle)
{
void* element = NULL;
assertIterator(iteratorHandle);
if (currentElement)
{
UtlVoidPtr* elementContainer = (UtlVoidPtr*)list.removeReference(currentElement);
if(elementContainer)
{
element = (void*) elementContainer->getValue();
delete elementContainer;
currentElement=NULL;
}
}
return(element);
}
void sipxLineObjectFree(const SIPX_LINE hLine)
{
// First remove it from the HandleMap so no one else an find it
SIPX_LINE_DATA* pData =
(SIPX_LINE_DATA *)gpLineHandleMap->removeHandle(hLine) ;
if (pData)
{
// Then lock it so anyone who was previously using it is known
// to have released it
if (pData->pMutex->acquireWrite() == OS_SUCCESS)
{
// Now it is safe to delete
pData->pInst->pLock->acquire() ;
pData->pInst->nLines-- ;
assert(pData->pInst->nLines >= 0) ;
pData->pInst->pLock->release() ;
if (pData->lineURI)
{
delete pData->lineURI ;
}
if (pData->pMutex)
{
delete pData->pMutex ;
}
if (pData->pLineAliases)
{
UtlVoidPtr* pValue ;
while (pValue = (UtlVoidPtr*) pData->pLineAliases->get())
{
Url* pUri = (Url*) pValue->getValue() ;
if (pUri)
{
delete pUri ;
}
delete pValue ;
}
}
delete pData ;
}
}
}
UtlBoolean HttpServer::findRequestProcessor(const char* fileUri,
RequestProcessor* &requestProcessor
)
{
UtlString uriCollectable(fileUri);
UtlVoidPtr* processorCollectable;
requestProcessor = NULL;
processorCollectable =
(UtlVoidPtr*) mRequestProcessorMethods.findValue(&uriCollectable);
if(processorCollectable)
{
requestProcessor = (RequestProcessor*)processorCollectable->getValue();
}
return(requestProcessor != NULL);
}
const void* SipXHandleMap::findHandle(SIPXHANDLE handle)
{
lock() ;
const void* pRC = NULL ;
UtlInt key(handle) ;
UtlVoidPtr* pValue ;
pValue = (UtlVoidPtr*) findValue(&key) ;
if (pValue != NULL)
{
pRC = pValue->getValue() ;
}
unlock() ;
return pRC ;
}
void SipXHandleMap::dumpCalls()
{
UtlHashMapIterator itor(*this) ;
UtlInt* pKey ;
UtlVoidPtr* pValue ;
while ((pKey = (UtlInt*) itor()))
{
pValue = (UtlVoidPtr*) findValue(pKey) ;
assert(pValue != NULL);
SIPX_CALL_DATA* pCallData = (SIPX_CALL_DATA*)pValue->getValue();
printf("\tkey=%08d, value=0x%p, CallId=%s SessionCallId=%s\n",
pKey->getValue(),
pValue->getValue(),
pCallData->callId?pCallData->callId->data():"NULL",
pCallData->sessionCallId?pCallData->sessionCallId->data():"NULL") ;
}
}
SIPX_CALL sipxCallLookupHandle(const UtlString& callID, const void* pSrc)
{
SIPX_CALL hCall = 0 ;
if (gpCallHandleMap->lock())
{
UtlHashMapIterator iter(*gpCallHandleMap);
UtlInt* pIndex = NULL;
UtlVoidPtr* pObj = NULL;
while ((pIndex = dynamic_cast<UtlInt*>( iter() )) )
{
pObj = dynamic_cast<UtlVoidPtr*>(gpCallHandleMap->findValue(pIndex));
SIPX_CALL_DATA* pData = NULL ;
if (pObj)
{
pData = (SIPX_CALL_DATA*) pObj->getValue() ;
}
if (pData &&
(pData->callId->compareTo(callID) == 0 ||
(pData->sessionCallId && (pData->sessionCallId->compareTo(callID) == 0)) ||
(pData->transferCallId && (pData->transferCallId->compareTo(callID) == 0))) &&
pData->pInst->pCallManager == pSrc)
{
hCall = pIndex->getValue() ;
#ifdef DUMP_CALLS
OsSysLog::add(FAC_SIPXTAPI, PRI_DEBUG, "***************** LookupHandle ***\nhCall %d\n****callId %s\n***sessionCallId %s\n",
hCall,
pData->callId ? pData->callId->data() : NULL,
pData->sessionCallId ? pData->sessionCallId->data() : NULL);
#endif
break ;
}
}
gpCallHandleMap->unlock() ;
}
return hCall;
}
SIPX_INSTANCE_DATA* findSessionByCallManager(const void* pCallManager)
{
SIPX_INSTANCE_DATA *pInst = NULL ;
UtlDListIterator iter(*gpSessionList);
UtlVoidPtr* pObj = NULL;
while ((pObj = dynamic_cast<UtlVoidPtr*>(iter())))
{
SIPX_INSTANCE_DATA* pTest = (SIPX_INSTANCE_DATA*) pObj->getValue() ;
if ((pTest) && (pTest->pCallManager == pCallManager))
{
pInst = pTest ;
break ;
}
}
return pInst ;
}
// Retrieve the value associated with the specified key.
// If pValue is non-NULL, the value is returned via pValue.
// Return OS_SUCCESS if the lookup is successful, return OS_NOT_FOUND if
// there is no match for the specified key.
OsStatus OsNameDb::lookup(const UtlString& rKey,
void** pValue)
{
OsReadLock lock(mRWLock);
OsStatus result = OS_NOT_FOUND;
UtlVoidPtr* pDictValue;
pDictValue = (UtlVoidPtr*)
mDict.findValue(&rKey); // perform the lookup
if (pDictValue != NULL)
{
if (pValue != NULL) // if we have a valid pointer,
{ // return the corresponding value
*pValue = pDictValue->getValue();
}
result = OS_SUCCESS;
}
return result;
}
void sipxDumpCalls()
{
if (gpCallHandleMap->lock())
{
UtlHashMapIterator iter(*gpCallHandleMap);
UtlInt* pIndex = NULL;
UtlVoidPtr* pObj = NULL;
SIPX_CALL hCall = 0 ;
while (pIndex = dynamic_cast<UtlInt*>( iter() ) )
{
pObj = dynamic_cast<UtlVoidPtr*>(gpCallHandleMap->findValue(pIndex));
SIPX_CALL_DATA* pData = NULL ;
if (pObj)
{
pData = (SIPX_CALL_DATA*) pObj->getValue() ;
}
if (pData)
{
hCall = pIndex->getValue() ;
OsSysLog::add(FAC_SIPXTAPI, PRI_DEBUG,
"***************** CallDump***\n"
"hCall %d\n"
"****callId %s\n"
"****ghostCallId %s\n"
"***bRemoveInsteadOfDrop %d\n"
"****lineUri %s\n",
hCall,
pData->callId ? pData->callId->data() : NULL,
pData->ghostCallId ? pData->ghostCallId->data() : NULL,
pData->bRemoveInsteadOfDrop,
pData->lineURI ? pData->lineURI->data() : NULL);
}
}
gpCallHandleMap->unlock() ;
}
}
const void* SipXHandleMap::removeHandle(SIPXHANDLE handle)
{
lock() ;
releaseHandleRef(handle);
const void* pRC = NULL ;
UtlInt key(handle) ;
UtlInt* pCount = static_cast<UtlInt*>(mLockCountHash.findValue(&key)) ;
if (pCount == NULL || pCount->getValue() < 1)
{
UtlVoidPtr* pValue ;
pValue = (UtlVoidPtr*) findValue(&key) ;
if (pValue != NULL)
{
pRC = pValue->getValue() ;
if(! destroy(&key))
{
OsSysLog::add(FAC_SIPXTAPI, PRI_ERR,
"SipXHandleMap::removeHandle failed to destroy handle: %d",
handle);
}
}
if (pCount)
{
if(! mLockCountHash.destroy(&key))
{
OsSysLog::add(FAC_SIPXTAPI, PRI_ERR,
"SipXHandleMap::removeHandle failed to destroy lock count for handle: %d",
handle);
}
}
}
unlock() ;
return pRC ;
}
UtlBoolean SipUdpServer::sendTo(const SipMessage& message,
const char* address,
int port,
const char* szLocalSipIp)
{
UtlBoolean sendOk;
UtlVoidPtr* pServerContainer = NULL;
SipClient* pServer = NULL;
if (szLocalSipIp)
{
UtlString localKey(szLocalSipIp);
pServerContainer = (UtlVoidPtr*)this->mServers.findValue(&localKey);
if (pServerContainer)
{
pServer = (SipClient*) pServerContainer->getValue();
}
}
else
{
// no local sip IP specified, so, use the default one
UtlString defaultKey(mDefaultIp);
pServerContainer = (UtlVoidPtr*) mServers.findValue(&defaultKey);
if (pServerContainer)
{
pServer = (SipClient*) pServerContainer->getValue();
}
}
if (pServer)
{
sendOk = pServer->sendTo(message, address, port);
}
else
{
sendOk = false;
}
return(sendOk);
}
/** Test the setValue() method.
*
* The test data for this method is
* a) For a NULL pointer set a different type
* a) Set the value from one Non-NULL to another Non-NULL
* d) set the value from Non-NULL to NULL
*/
void testSetValue()
{
const char* prefix ;
const char* suffix1 = " : test return value" ;
const char* suffix2 = " : test that value has been set" ;
string Message ;
UtlVoidPtr testVoidObj ;
void* returnValue ;
void* newValue ;
void* oldValue = 0 ;
newValue = (void*)"Hello world" ;
returnValue = testVoidObj.setValue(newValue) ;
prefix = "For a VoidPtr object which is not NULL, test setValue(void* value) " \
"where val is non NULL " ;
TestUtilities::createMessage(2, &Message, prefix, suffix1) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), (void*)oldValue, (void*)returnValue) ;
TestUtilities::createMessage(2, &Message, prefix, suffix2) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), (void*)newValue, \
(void*)testVoidObj.getValue()) ;
oldValue = testVoidObj.getValue() ;
prefix = "Test setValue(void* value) where value is not NULL and the " \
"existing object is not NULL" ;
newValue = (void*)"Hello again world" ;
returnValue = (void*)testVoidObj.setValue(newValue) ;
TestUtilities::createMessage(2, &Message, prefix, suffix1) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), (void*)oldValue, (void*)returnValue) ;
TestUtilities::createMessage(2, &Message, prefix, suffix2) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), (void*)newValue, \
(void*)testVoidObj.getValue()) ;
oldValue = testVoidObj.getValue() ;
prefix = "Test setValue(void* value) where value = NULL and existing object is not" ;
newValue = 0 ;
returnValue = (void*)testVoidObj.setValue(newValue) ;
TestUtilities::createMessage(2, &Message, prefix, suffix1) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), (void*)oldValue, (void*)returnValue);
TestUtilities::createMessage(2, &Message, prefix, suffix1) ;
CPPUNIT_ASSERT_EQUAL_MESSAGE(Message.data(), (void*)newValue, \
(void*)testVoidObj.getValue()) ;
} //testSetValue
// Remove the indicated key-value pair from the name database.
// If pValue is non-NULL, the value for the key-value pair is returned
// via pValue.
// Return OS_SUCCESS if the lookup is successful, return OS_NOT_FOUND
// if there is no match for the specified key.
OsStatus OsNameDb::remove(const UtlString& rKey,
void** pValue)
{
OsWriteLock lock(mRWLock);
OsStatus result = OS_NOT_FOUND;
UtlString* pDictKey;
UtlContainable* pDictValue;
pDictKey = dynamic_cast<UtlString*>
(mDict.removeKeyAndValue(&rKey, pDictValue));
// If a value was found and removed ...
if (pDictKey != NULL)
{
result = OS_SUCCESS;
// If the caller provided a pointer through which to return the
// integer value, do so.
if (pValue != NULL)
{
UtlVoidPtr* voidPtrValue = dynamic_cast<UtlVoidPtr*>(pDictValue);
if (voidPtrValue)
{
*pValue = voidPtrValue->getValue();
}
else
{
result = OS_NOT_FOUND;
}
}
// Delete the key and value objects.
delete pDictKey;
delete pDictValue;
}
// Return success or failure as appropriate.
return result;
}
//! Terminate the non-Terminated contents of mXmlDialogs.
void ResourceInstance::terminateXmlDialogs()
{
OsSysLog::add(FAC_RLS, PRI_DEBUG,
"ResourceInstance::terminateXmlDialogs mInstanceName = '%s'",
mInstanceName.data());
// Iterate through the contents.
UtlHashMapIterator itor(mXmlDialogs);
UtlContainable* id;
while ((id = itor()))
{
// The XML document for a single dialog.
UtlVoidPtr* value = dynamic_cast <UtlVoidPtr*> (itor.value());
TiXmlElement* dialog_element = static_cast <TiXmlElement*> (value->getValue());
if (NULL != dialog_element)
{
// Get the "state" XML node.
TiXmlNode* state = dialog_element->FirstChild("state");
// Destroy the dialog only if the state is not "terminated".
UtlString stateText;
textContentShallow(stateText, state); // textContentShallow allows state == NULL.
// Check if the state is not terminated.
if (0 != stateText.compareTo("terminated"))
{
TiXmlElement newstate = "state";
TiXmlText newtext = "terminated";
// Replace the old state element with a new state element indicating terminated.
// The calling routine will then normally overwrite this with the actual (full) state.
// Note that tinyxml will delete the old state element for us.
newstate.InsertEndChild(newtext);
dialog_element->ReplaceChild(state, newstate);
}
}
}
}
