void WinReadWriteLock::unlock()
{
if (m_lock.Ptr == (PVOID)1)
unlockForWrite();
else
unlockForRead();
}
UtlBoolean SipSubscribeServer::enableEventType(const char* eventTypeToken,
SipUserAgent* userAgent,
SipPublishContentMgr* contentMgr,
SipSubscribeServerEventHandler* eventHandler,
SipSubscriptionMgr* subscriptionMgr)
{
UtlBoolean addedEvent = FALSE;
UtlString eventName(eventTypeToken ? eventTypeToken : "");
lockForWrite();
// Only add the event support if it does not already exist;
SubscribeServerEventData* eventData =
(SubscribeServerEventData*) mEventDefinitions.find(&eventName);
if(!eventData)
{
addedEvent = TRUE;
eventData = new SubscribeServerEventData();
*((UtlString*)eventData) = eventName;
eventData->mpEventSpecificUserAgent = userAgent ? userAgent : mpDefaultUserAgent;
eventData->mpEventSpecificContentMgr = contentMgr ? contentMgr : mpDefaultContentMgr;
eventData->mpEventSpecificHandler = eventHandler ? eventHandler : mpDefaultEventHandler;
eventData->mpEventSpecificSubscriptionMgr = subscriptionMgr ? subscriptionMgr : mpDefaultSubscriptionMgr;
mEventDefinitions.insert(eventData);
// Register an interest in SUBSCRIBE requests and NOTIFY responses
// for this event type
eventData->mpEventSpecificUserAgent->addMessageObserver(*(getMessageQueue()),
SIP_SUBSCRIBE_METHOD,
TRUE, // requests
FALSE, // not reponses
TRUE, // incoming
FALSE, // no outgoing
eventName,
NULL,
NULL);
eventData->mpEventSpecificUserAgent->addMessageObserver(*(getMessageQueue()),
SIP_NOTIFY_METHOD,
FALSE, // no requests
TRUE, // reponses
TRUE, // incoming
FALSE, // no outgoing
eventName,
NULL,
NULL);
// Register the callback for changes that occur in the
// publish content manager
eventData->mpEventSpecificContentMgr->setContentChangeObserver(eventName,
this, contentChangeCallback);
}
unlockForWrite();
return(addedEvent);
}
UtlBoolean SipSubscribeServer::disableEventType(const char* eventTypeToken,
SipUserAgent*& userAgent,
SipPublishContentMgr*& contentMgr,
SipSubscribeServerEventHandler*& eventHandler,
SipSubscriptionMgr*& subscriptionMgr)
{
UtlBoolean removedEvent = FALSE;
UtlString eventName(eventTypeToken ? eventTypeToken : "");
lockForWrite();
// Only add the event support if it does not already exist;
SubscribeServerEventData* eventData =
(SubscribeServerEventData*) mEventDefinitions.remove(&eventName);
if(eventData)
{
removedEvent = TRUE;
userAgent = eventData->mpEventSpecificUserAgent == mpDefaultUserAgent ?
NULL : eventData->mpEventSpecificUserAgent;
contentMgr = eventData->mpEventSpecificContentMgr == mpDefaultContentMgr ?
NULL : eventData->mpEventSpecificContentMgr;
eventHandler = eventData->mpEventSpecificHandler == mpDefaultEventHandler ?
NULL : eventData->mpEventSpecificHandler;
subscriptionMgr = eventData->mpEventSpecificSubscriptionMgr == mpDefaultSubscriptionMgr ?
NULL : eventData->mpEventSpecificSubscriptionMgr;
// Unregister interest in SUBSCRIBE requests and NOTIFY
// responses for this event type
eventData->mpEventSpecificUserAgent->removeMessageObserver(*(getMessageQueue()));
delete eventData;
eventData = NULL;
}
else
{
userAgent = NULL;
contentMgr = NULL;
eventHandler = NULL;
subscriptionMgr = NULL;
}
unlockForWrite();
return(removedEvent);
}
UtlBoolean SipPublishServer::disableEventType(const char* eventType)
{
UtlString eventName(eventType);
lockForWrite();
PublishServerEventData* eventData =
dynamic_cast <PublishServerEventData*> (mEventDefinitions.remove(&eventName));
if (eventData)
{
// Unregister interest in PUBLISH requests for this event type
eventData->mpEventSpecificUserAgent->removeMessageObserver(*(getMessageQueue()));
delete eventData;
}
unlockForWrite();
return eventData != NULL;
}
UtlBoolean SipSubscribeServer::disableEventType(const char* eventType)
{
// :TODO: We should terminate all subscriptions for this event type.
UtlString eventName(eventType);
lockForWrite();
SubscribeServerEventData* eventData =
dynamic_cast <SubscribeServerEventData*> (mEventDefinitions.remove(&eventName));
if (eventData)
{
// Unregister interest in SUBSCRIBE requests and NOTIFY
// responses for this event type
eventData->mpEventSpecificUserAgent->removeMessageObserver(*(getMessageQueue()));
delete eventData;
}
unlockForWrite();
return eventData != NULL;
}
UtlBoolean SipPublishServer::disableEventType(const char* eventTypeToken,
SipUserAgent*& userAgent,
SipPublishServerEventStateMgr*& eventStateMgr,
SipPublishServerEventStateCompositor*& eventStateCompositor)
{
UtlBoolean removedEvent = FALSE;
UtlString eventName(eventTypeToken ? eventTypeToken : "");
lockForWrite();
// Only add the event support if it does not already exist;
PublishServerEventData* eventData =
(PublishServerEventData*) mEventDefinitions.remove(&eventName);
if(eventData)
{
removedEvent = TRUE;
userAgent = eventData->mpEventSpecificUserAgent == mpDefaultUserAgent ?
NULL : eventData->mpEventSpecificUserAgent;
eventStateCompositor = eventData->mpEventSpecificStateCompositor == mpDefaultCompositor ?
NULL : eventData->mpEventSpecificStateCompositor;
eventStateMgr = eventData->mpEventSpecificStateMgr == mpDefaultEventStateMgr ?
NULL : eventData->mpEventSpecificStateMgr;
// Unregister interest in PUBLISH requests for this event type
eventData->mpEventSpecificUserAgent->removeMessageObserver(*(getMessageQueue()));
delete eventData;
eventData = NULL;
}
else
{
userAgent = NULL;
eventStateCompositor = NULL;
eventStateMgr = NULL;
}
unlockForWrite();
return(removedEvent);
}
UtlBoolean SipPublishServer::enableEventType(const char* eventTypeToken,
SipUserAgent* userAgent,
SipPublishServerEventStateMgr* eventStateMgr,
SipPublishServerEventStateCompositor* eventStateCompositor)
{
UtlBoolean addedEvent = FALSE;
UtlString eventName(eventTypeToken ? eventTypeToken : "");
lockForWrite();
// Only add the event support if it does not already exist;
PublishServerEventData* eventData =
(PublishServerEventData*) mEventDefinitions.find(&eventName);
if(!eventData)
{
addedEvent = TRUE;
eventData = new PublishServerEventData();
*((UtlString*)eventData) = eventName;
eventData->mpEventSpecificUserAgent = userAgent ? userAgent : mpDefaultUserAgent;
eventData->mpEventSpecificStateCompositor = eventStateCompositor ? eventStateCompositor : mpDefaultCompositor;
eventData->mpEventSpecificStateMgr = eventStateMgr ? eventStateMgr : mpDefaultEventStateMgr;
mEventDefinitions.insert(eventData);
// Register an interest in PUBLISH requests for this event type
eventData->mpEventSpecificUserAgent->addMessageObserver(*(getMessageQueue()),
SIP_PUBLISH_METHOD,
TRUE, // requests
FALSE, // not reponses
TRUE, // incoming
FALSE, // no outgoing
eventName,
NULL,
NULL);
}
unlockForWrite();
return(addedEvent);
}
/// Terminate all subscriptions and accept no new ones.
void SipSubscribeServer::shutdown(const char* reason)
{
// If reason is NULL, use the default reason established by the constructor.
if (!reason)
{
reason = mDefaultTermination;
}
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"SipSubscribeServer::shutdown reason '%s'",
reason ? reason : "[null]");
lockForRead();
// Select the subscriptionChange value to describe what we're doing
// with the subscriptions.
enum SipSubscriptionMgr::subscriptionChange change;
// Select the correct format for generating the Subscription-State value.
UtlString* formatp = NULL; // We may need a temp UtlString.
const char* format;
if (reason == NULL)
{
format = "active;expires=%ld";
change = SipSubscriptionMgr::subscriptionContinues;
}
else if (strcmp(reason, terminationReasonSilent) == 0)
{
// Do not admit that the subscription is ending.
format = "active;expires=%ld";
change = SipSubscriptionMgr::subscriptionTerminatedSilently;
}
else if (strcmp(reason, terminationReasonNone) == 0)
{
format = "terminated";
change = SipSubscriptionMgr::subscriptionTerminated;
}
else
{
// Allocate a UtlString and assemble the Subscription-State format in it.
formatp = new UtlString();
formatp->append("terminated;reason=");
formatp->append(reason);
format = formatp->data();
change = SipSubscriptionMgr::subscriptionTerminated;
}
// For each event type that is registered, delete all the subscriptions.
UtlHashBagIterator event_itor(mEventDefinitions);
SubscribeServerEventData* eventData;
while ((eventData =
dynamic_cast <SubscribeServerEventData*> (event_itor())))
{
// Unregister interest in SUBSCRIBE requests and NOTIFY
// responses for this event type, so we do not service new subscriptions.
eventData->mpEventSpecificUserAgent->removeMessageObserver(*(getMessageQueue()));
int numSubscriptions = 0;
SipMessage** notifyArray = NULL;
UtlString** acceptHeaderValuesArray = NULL;
UtlString** resourceIdArray = NULL;
UtlString** eventTypeKeyArray = NULL;
// :TODO: The four situations where NOTIFYs are generated should
// be factored into a series of methods in
// mpEventSpecificSubscriptionMgr that generate NOTIFYs
// sequentially, and for each NOTIFY, call a common service
// method that does the remaining operations and sends the
// NOTIFY.
// Construct a NOTIFY (without body) for every subscription, containing
// the dialog-related information about each subscription.
eventData->mpEventSpecificSubscriptionMgr->
createNotifiesDialogInfoEvent(static_cast <const UtlString&> (*eventData),
format,
numSubscriptions,
acceptHeaderValuesArray,
notifyArray,
resourceIdArray,
eventTypeKeyArray);
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"SipSubscribeServer::shutdown eventType = '%s', numSubscriptions = %d",
eventData->data(), numSubscriptions);
// For each NOTIFY, add the subscription-related information and then
// send it.
for (int notifyIndex = 0;
notifyIndex < numSubscriptions;
notifyIndex++)
{
SipMessage* notify = notifyArray[notifyIndex];
// Check to see if the dialog information could be added.
// (The subscription might have been destroyed between when
// it was decided to respond to it, and when the dialog information
// was retrieved.)
UtlString callId;
notify->getCallIdField(&callId);
if (!callId.isNull())
{
if (change != SipSubscriptionMgr::subscriptionTerminatedSilently)
{
// Fill in the NOTIFY request body/content
eventData->mpEventSpecificHandler->
getNotifyContent(*(resourceIdArray[notifyIndex]),
*(eventTypeKeyArray[notifyIndex]),
*eventData,
*(eventData->mpEventSpecificContentMgr),
*(acceptHeaderValuesArray[notifyIndex]),
*notify,
eventData->mEventSpecificFullState,
NULL);
// Call the application callback to edit the NOTIFY
// content if that is required for this event type.
// Also gets 'version' (if relevant) and 'savedEventTypeKey'.
int version;
UtlString savedEventTypeKey;
eventData->mpEventSpecificSubscriptionMgr->
updateNotifyVersion(eventData->mpEventSpecificContentVersionCallback,
*notify,
version,
savedEventTypeKey);
// Set the Contact header.
setContact(notify);
// Send the NOTIFY request.
eventData->mpEventSpecificUserAgent->send(*notify);
}
// Remove the record of the subscription.
UtlString dialogHandle;
notify->getDialogHandle(dialogHandle);
eventData->mpEventSpecificSubscriptionMgr->
endSubscription(dialogHandle, change);
}
}
// Free the NOTIFY requests and accept header field values.
SipSubscriptionMgr::freeNotifies(numSubscriptions,
acceptHeaderValuesArray,
notifyArray);
// Free the resource and event type arrays.
for (int index = 0;
index < numSubscriptions;
index++)
{
delete resourceIdArray[index];
delete eventTypeKeyArray[index];
}
delete[] resourceIdArray;
delete[] eventTypeKeyArray;
// Remove eventData from mEventDefinitions.
mEventDefinitions.removeReference(eventData);
delete eventData;
}
unlockForRead();
// Free the temporary UtlString, if necessary.
if (formatp)
{
delete formatp;
}
lockForWrite();
mEventDefinitions.destroyAll();
unlockForWrite();
}
