#include <DialogUsageManager.hxx>
Detailed Description
Definition at line 77 of file DialogUsageManager.hxx.
Member Typedef Documentation
typedef std::map<Data, DialogSet*> resip::DialogUsageManager::CancelMap [private] |
Definition at line 490 of file DialogUsageManager.hxx.
typedef HashMap<DialogSetId, DialogSet*> resip::DialogUsageManager::DialogSetMap [private] |
Definition at line 493 of file DialogUsageManager.hxx.
typedef std::map<Data, DumFeatureChain*> resip::DialogUsageManager::FeatureChainMap [protected] |
Definition at line 368 of file DialogUsageManager.hxx.
typedef std::set<MergedRequestKey> resip::DialogUsageManager::MergedRequests [private] |
Definition at line 487 of file DialogUsageManager.hxx.
typedef std::map<Data, SipMessage*> resip::DialogUsageManager::RequiresCerts [private] |
Definition at line 546 of file DialogUsageManager.hxx.
typedef std::map<Data, ServerPublication*> resip::DialogUsageManager::ServerPublications [private] |
Definition at line 544 of file DialogUsageManager.hxx.
typedef std::multimap<Data, ServerSubscription*> resip::DialogUsageManager::ServerSubscriptions [private] |
Definition at line 550 of file DialogUsageManager.hxx.
Member Enumeration Documentation
Definition at line 92 of file DialogUsageManager.hxx.
{
None = 0,
Sign,
Encrypt,
SignAndEncrypt
} EncryptionLevel;
enum resip::DialogUsageManager::ShutdownState [private] |
Definition at line 533 of file DialogUsageManager.hxx.
{
Running,
ShutdownRequested, // while ending usages
RemovingTransactionUser, // while removing TU from stack
Shutdown, // after TU has been removed from stack
Destroying // while calling destructor
} ShutdownState;
Constructor & Destructor Documentation
| DialogUsageManager::DialogUsageManager | ( | SipStack & | stack, |
| bool | createDefaultFeatures = false |
||
| ) |
Definition at line 94 of file DialogUsageManager.cxx.
References addIncomingFeature(), addOutgoingFeature(), addServerSubscriptionHandler(), resip::TransactionUser::mFifo, mIncomingTarget, mOutgoingTarget, mStack, resip::SipStack::registerTransactionUser(), and resip::FifoStatsInterface::setDescription().
: TransactionUser(TransactionUser::DoNotRegisterForTransactionTermination, TransactionUser::RegisterForConnectionTermination, TransactionUser::RegisterForKeepAlivePongs), mRedirectManager(new RedirectManager()), mInviteSessionHandler(0), mClientRegistrationHandler(0), mServerRegistrationHandler(0), mRedirectHandler(0), mDialogSetHandler(0), mRequestValidationHandler(0), mRegistrationPersistenceManager(0), mIsDefaultServerReferHandler(true), mClientPagerMessageHandler(0), mServerPagerMessageHandler(0), mDialogEventStateManager(0), mAppDialogSetFactory(new AppDialogSetFactory()), mStack(stack), mDumShutdownHandler(0), mShutdownState(Running), mThreadDebugKey(0), mHiddenThreadDebugKey(0) { //TODO -- create default features mStack.registerTransactionUser(*this); addServerSubscriptionHandler("refer", new DefaultServerReferHandler()); mFifo.setDescription("DialogUsageManager::mFifo"); mIncomingTarget = new IncomingTarget(*this); mOutgoingTarget = new OutgoingTarget(*this); if (createDefaultFeatures) { SharedPtr<IdentityHandler> identity = SharedPtr<IdentityHandler>(new IdentityHandler(*this, *mIncomingTarget)); #if defined (USE_SSL) SharedPtr<EncryptionManager> encryptionIncoming = SharedPtr<EncryptionManager>(new EncryptionManager(*this, *mIncomingTarget)); SharedPtr<EncryptionManager> encryptionOutgoing = SharedPtr<EncryptionManager>(new EncryptionManager(*this, *mOutgoingTarget)); #endif // default incoming features. addIncomingFeature(identity); #if defined (USE_SSL) addIncomingFeature(encryptionIncoming); #endif // default outgoing features. #if defined (USE_SSL) addOutgoingFeature(encryptionOutgoing); #endif } }
| DialogUsageManager::~DialogUsageManager | ( | ) | [virtual] |
Definition at line 150 of file DialogUsageManager.cxx.
References DebugLog, Destroying, mDialogSetMap, mIncomingTarget, mIsDefaultServerReferHandler, mOutgoingTarget, mServerSubscriptionHandlers, and mShutdownState.
{
mShutdownState = Destroying;
//InfoLog ( << "~DialogUsageManager" );
#if(0)
// !kh!
DialogSetMap::iterator dialogSet = mDialogSetMap.begin();
for (; dialogSet != mDialogSetMap.end(); ++dialogSet)
{
delete dialogSet->second;
}
#endif
if(!mDialogSetMap.empty())
{
DebugLog(<< "DialogUsageManager::mDialogSetMap has " << mDialogSetMap.size() << " DialogSets");
DialogSetMap::const_iterator ds = mDialogSetMap.begin();
for(; ds != mDialogSetMap.end(); ++ds)
{
DebugLog(<< "DialgSetId:" << ds->first);
DialogSet::DialogMap::const_iterator d = ds->second->mDialogs.begin();
for(; d != ds->second->mDialogs.end(); ++d)
{
//const Dialog* p = &(d->second);
DebugLog(<<"DialogId:" << d->first << ", " << *d->second);
}
}
}
while(!mDialogSetMap.empty())
{
DialogSet* ds = mDialogSetMap.begin()->second;
delete ds;
}
if(mIsDefaultServerReferHandler)
{
delete mServerSubscriptionHandlers["refer"];
}
delete mIncomingTarget;
delete mOutgoingTarget;
//InfoLog ( << "~DialogUsageManager done" );
}
Member Function Documentation
| void DialogUsageManager::addClientPublicationHandler | ( | const Data & | eventType, |
| ClientPublicationHandler * | handler | ||
| ) |
If there is no such handler, calling makePublication will throw.
Definition at line 441 of file DialogUsageManager.cxx.
References mClientPublicationHandlers.
Referenced by main(), and resip::UserAgent::UserAgent().
{
assert(handler);
assert(mClientPublicationHandlers.count(eventType) == 0);
mClientPublicationHandlers[eventType] = handler;
}
| void DialogUsageManager::addClientSubscriptionHandler | ( | const Data & | eventType, |
| ClientSubscriptionHandler * | handler | ||
| ) |
If there is no such handler, calling makeSubscription will throw.
Definition at line 418 of file DialogUsageManager.cxx.
References mClientSubscriptionHandlers.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), RegEventClient::RegEventClient(), and resip::UserAgent::UserAgent().
{
assert(handler);
assert(mClientSubscriptionHandlers.count(eventType) == 0);
mClientSubscriptionHandlers[eventType] = handler;
}
| void DialogUsageManager::addExternalMessageHandler | ( | ExternalMessageHandler * | handler | ) |
Add/Remove External Message Handler do following op when processing thread in not running.
Definition at line 477 of file DialogUsageManager.cxx.
References mExternalMessageHandlers.
{
std::vector<ExternalMessageHandler*>::iterator found = std::find(mExternalMessageHandlers.begin(), mExternalMessageHandlers.end(), handler);
if (found == mExternalMessageHandlers.end())
{
mExternalMessageHandlers.push_back(handler);
}
}
| void DialogUsageManager::addIncomingFeature | ( | resip::SharedPtr< DumFeature > | feat | ) |
Definition at line 2375 of file DialogUsageManager.cxx.
References mIncomingFeatureList.
Referenced by DialogUsageManager().
{
mIncomingFeatureList.push_back(feat);
}
| void DialogUsageManager::addOutgoingFeature | ( | resip::SharedPtr< DumFeature > | feat | ) |
Definition at line 2381 of file DialogUsageManager.cxx.
References mOutgoingFeatureList.
Referenced by DialogUsageManager().
{
// make sure EncryptionManager is the last feature in the list.
mOutgoingFeatureList.insert(mOutgoingFeatureList.begin(), feat);
}
| void DialogUsageManager::addOutOfDialogHandler | ( | MethodTypes | type, |
| OutOfDialogHandler * | handler | ||
| ) |
Definition at line 457 of file DialogUsageManager.cxx.
References mOutOfDialogHandlers.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), main(), and resip::UserAgent::UserAgent().
{
assert(handler);
assert(mOutOfDialogHandlers.count(type) == 0);
mOutOfDialogHandlers[type] = handler;
}
| void DialogUsageManager::addServerPublicationHandler | ( | const Data & | eventType, |
| ServerPublicationHandler * | handler | ||
| ) |
Definition at line 449 of file DialogUsageManager.cxx.
References mServerPublicationHandlers.
{
assert(handler);
assert(mServerPublicationHandlers.count(eventType) == 0);
mServerPublicationHandlers[eventType] = handler;
}
| void DialogUsageManager::addServerSubscriptionHandler | ( | const Data & | eventType, |
| ServerSubscriptionHandler * | handler | ||
| ) |
Definition at line 426 of file DialogUsageManager.cxx.
References mIsDefaultServerReferHandler, and mServerSubscriptionHandlers.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), DialogUsageManager(), and main().
{
assert(handler);
//default do-nothing server side refer handler can be replaced
if (eventType == "refer" && mServerSubscriptionHandlers.count(eventType))
{
delete mServerSubscriptionHandlers[eventType];
mIsDefaultServerReferHandler = false;
//mServerSubscriptionHandlers.erase(eventType);
}
mServerSubscriptionHandlers[eventType] = handler;
}
| void DialogUsageManager::addTimer | ( | DumTimeout::Type | type, |
| unsigned long | durationSeconds, | ||
| BaseUsageHandle | target, | ||
| unsigned int | seq, | ||
| unsigned int | altseq = 0 |
||
| ) | [private] |
Definition at line 401 of file DialogUsageManager.cxx.
References mStack, and resip::SipStack::post().
Referenced by resip::ClientRegistration::checkProfileRetry(), resip::ClientPublication::dispatch(), resip::ClientRegistration::dispatch(), resip::ClientSubscription::end(), resip::ClientSubscription::processResponse(), resip::ClientSubscription::requestRefresh(), resip::ClientSubscription::scheduleRefresh(), resip::ServerPublication::send(), resip::ServerSubscription::send(), resip::ClientSubscription::send(), resip::ServerInviteSession::startRetransmit1xxTimer(), resip::InviteSession::startSessionTimer(), resip::ClientInviteSession::startStaleCallTimer(), and resip::InviteSession::startStaleReInviteTimer().
{
DumTimeout t(type, duration, target, cseq, rseq);
mStack.post(t, duration, this);
}
| void DialogUsageManager::addTimerMs | ( | DumTimeout::Type | type, |
| unsigned long | duration, | ||
| BaseUsageHandle | target, | ||
| unsigned int | seq, | ||
| unsigned int | altseq = 0, |
||
| const Data & | transactionId = Data::Empty |
||
| ) | [private] |
Definition at line 409 of file DialogUsageManager.cxx.
References mStack, and resip::SipStack::postMS().
Referenced by resip::InviteSession::dispatch(), resip::ClientInviteSession::onForkAccepted(), resip::InviteSession::sendAck(), resip::InviteSession::start491Timer(), resip::ClientInviteSession::startCancelTimer(), and resip::InviteSession::startRetransmit200Timer().
{
DumTimeout t(type, duration, target, cseq, rseq, transactionId);
mStack.postMS(t, duration, this);
}
| void DialogUsageManager::addTransport | ( | TransportType | protocol, |
| int | port = 0, |
||
| IpVersion | version = V4, |
||
| const Data & | ipInterface = Data::Empty, |
||
| const Data & | sipDomainname = Data::Empty, |
||
| const Data & | privateKeyPassPhrase = Data::Empty, |
||
| SecurityTypes::SSLType | sslType = SecurityTypes::TLSv1, |
||
| unsigned | transportFlags = 0 |
||
| ) |
Definition at line 204 of file DialogUsageManager.cxx.
References resip::SipStack::addTransport(), mStack, and resip::StunDisabled.
Referenced by resip::UserAgent::addTransport(), main(), and RegEventClient::RegEventClient().
{
mStack.addTransport(protocol, port, version, StunDisabled, ipInterface,
sipDomainname, privateKeyPassPhrase, sslType,
transportFlags);
}
| void DialogUsageManager::applyToAllClientSubscriptions | ( | ClientSubscriptionFunctor * | functor | ) |
Definition at line 2411 of file DialogUsageManager.cxx.
References resip::ClientSubscriptionFunctor::apply(), and mDialogSetMap.
{
assert(functor);
for (DialogSetMap::iterator it = mDialogSetMap.begin(); it != mDialogSetMap.end(); ++it)
{
for (DialogSet::DialogMap::iterator i = it->second->mDialogs.begin(); i != it->second->mDialogs.end(); ++i)
{
std::vector<ClientSubscriptionHandle> clientSubs = i->second->getClientSubscriptions();
for (std::vector<ClientSubscriptionHandle>::iterator ics = clientSubs.begin(); ics != clientSubs.end(); ++ics)
{
functor->apply(*ics);
}
}
}
}
| void DialogUsageManager::applyToAllServerSubscriptions | ( | ServerSubscriptionFunctor * | functor | ) |
Definition at line 2394 of file DialogUsageManager.cxx.
References resip::ServerSubscriptionFunctor::apply(), and mDialogSetMap.
{
assert(functor);
for (DialogSetMap::iterator it = mDialogSetMap.begin(); it != mDialogSetMap.end(); ++it)
{
for (DialogSet::DialogMap::iterator i = it->second->mDialogs.begin(); i != it->second->mDialogs.end(); ++i)
{
std::vector<ServerSubscriptionHandle> serverSubs = i->second->getServerSubscriptions();
for (std::vector<ServerSubscriptionHandle>::iterator iss = serverSubs.begin(); iss != serverSubs.end(); ++iss)
{
functor->apply(*iss);
}
}
}
}
| UnaryFunction resip::DialogUsageManager::applyToServerSubscriptions | ( | const Data & | aor, |
| const Data & | eventType, | ||
| UnaryFunction | applyFn | ||
| ) | [inline] |
Definition at line 309 of file DialogUsageManager.hxx.
References mServerSubscriptions.
{
Data key = eventType + aor;
std::pair<ServerSubscriptions::iterator,ServerSubscriptions::iterator>
range = mServerSubscriptions.equal_range(key);
for (ServerSubscriptions::iterator i=range.first; i!=range.second; ++i)
{
ServerSubscriptionHandle h = i->second->getHandle();
applyFn(h);
}
return applyFn;
}
| bool DialogUsageManager::checkEventPackage | ( | const SipMessage & | request | ) | [private] |
Definition at line 2197 of file DialogUsageManager.cxx.
References resip::SipMessage::exists(), getClientSubscriptionHandler(), getServerPublicationHandler(), getServerSubscriptionHandler(), h_RequestLine, resip::SipMessage::header(), InfoLog, makeResponse(), resip::RequestLine::method(), send(), and resip::RequestLine::unknownMethodName().
Referenced by resip::Dialog::dispatch(), processPublish(), and processRequest().
{
int failureCode = 0;
MethodTypes method = request.header(h_RequestLine).method();
// || (method == NOTIFY && !request.exists(h_SubscriptionState)))
if (!request.exists(h_Event))
{
InfoLog (<< "No Event header in " << request.header(h_RequestLine).unknownMethodName());
failureCode = 400;
}
else
{
switch(method)
{
case SUBSCRIBE:
if (!getServerSubscriptionHandler(request.header(h_Event).value()))
{
InfoLog (<< "No handler for event package for SUBSCRIBE: "
<< request.header(h_Event).value());
failureCode = 489;
}
break;
case NOTIFY:
if (!getClientSubscriptionHandler(request.header(h_Event).value()))
{
InfoLog (<< "No handler for event package for NOTIFY: "
<< request.header(h_Event).value());
failureCode = 489;
}
break;
case PUBLISH:
if (!getServerPublicationHandler(request.header(h_Event).value()))
{
InfoLog (<< "No handler for event package for PUBLISH: "
<< request.header(h_Event).value());
failureCode = 489;
}
break;
default:
assert(0);
}
}
if (failureCode > 0)
{
SharedPtr<SipMessage> response(new SipMessage);
makeResponse(*response, request, failureCode);
send(response);
return false;
}
return true;
}
| void DialogUsageManager::clearExternalMessageHandler | ( | ) |
Definition at line 497 of file DialogUsageManager.cxx.
References empty, and mExternalMessageHandlers.
{
std::vector<ExternalMessageHandler*> empty;
empty.swap(mExternalMessageHandlers);
}
| DialogEventStateManager * DialogUsageManager::createDialogEventStateManager | ( | DialogEventHandler * | handler | ) |
Definition at line 2467 of file DialogUsageManager.cxx.
References resip::DialogEventStateManager::mDialogEventHandler, and mDialogEventStateManager.
{
if(handler)
{
mDialogEventStateManager = new DialogEventStateManager();
mDialogEventStateManager->mDialogEventHandler = handler;
}
else
{
delete mDialogEventStateManager;
mDialogEventStateManager=0;
}
return mDialogEventStateManager;
}
| void DialogUsageManager::destroy | ( | const BaseUsage * | usage | ) | [private] |
Definition at line 1172 of file DialogUsageManager.cxx.
References Destroying, InfoLog, resip::BaseUsage::mHandle, mShutdownState, and resip::TransactionUser::post().
Referenced by resip::DialogSet::dispatch(), resip::ClientInviteSession::dispatch(), resip::ServerInviteSession::dispatchAccepted(), resip::ClientInviteSession::dispatchAnswered(), resip::ServerInviteSession::dispatchBye(), resip::InviteSession::dispatchBye(), resip::ServerInviteSession::dispatchCancel(), resip::ClientInviteSession::dispatchCancelled(), resip::ClientInviteSession::dispatchEarly(), resip::ClientInviteSession::dispatchEarlyWithAnswer(), resip::ClientInviteSession::dispatchEarlyWithOffer(), resip::ClientInviteSession::dispatchQueuedUpdate(), resip::ClientInviteSession::dispatchSentAnswer(), resip::ClientInviteSession::dispatchSentUpdateEarly(), resip::ClientInviteSession::dispatchSentUpdateEarlyGlare(), resip::ClientInviteSession::dispatchStart(), resip::InviteSession::dispatchTerminated(), resip::ServerInviteSession::dispatchUnknown(), resip::ServerInviteSession::dispatchWaitingToOffer(), resip::ServerInviteSession::dispatchWaitingToRequestOffer(), resip::ClientPagerMessage::end(), resip::ClientInviteSession::handleRedirect(), resip::DialogSet::possiblyDie(), resip::Dialog::possiblyDie(), resip::ServerInviteSession::redirect(), and resip::ServerInviteSession::reject().
{
if (mShutdownState != Destroying)
{
post(new DestroyUsage(usage->mHandle));
}
else
{
InfoLog(<< "DialogUsageManager::destroy() not posting to stack");
}
}
| void DialogUsageManager::destroy | ( | DialogSet * | dset | ) | [private] |
Definition at line 1185 of file DialogUsageManager.cxx.
References Destroying, InfoLog, mShutdownState, and resip::TransactionUser::post().
{
if (mShutdownState != Destroying)
{
post(new DestroyUsage(dset));
}
else
{
InfoLog(<< "DialogUsageManager::destroy() not posting to stack");
}
}
| void DialogUsageManager::destroy | ( | Dialog * | d | ) | [private] |
Definition at line 1198 of file DialogUsageManager.cxx.
References Destroying, InfoLog, mShutdownState, and resip::TransactionUser::post().
{
if (mShutdownState != Destroying)
{
post(new DestroyUsage(d));
}
else
{
InfoLog(<< "DialogUsageManager::destroy() not posting to stack");
}
}
| TargetCommand::Target & DialogUsageManager::dumIncomingTarget | ( | ) |
Definition at line 2455 of file DialogUsageManager.cxx.
References mIncomingTarget.
Referenced by resip::IdentityHandler::queueForIdentityCheck().
{
return *mIncomingTarget;
}
| TargetCommand::Target & DialogUsageManager::dumOutgoingTarget | ( | ) |
Definition at line 2461 of file DialogUsageManager.cxx.
References mOutgoingTarget.
{
return *mOutgoingTarget;
}
| void DialogUsageManager::end | ( | DialogSetId | invSessionId | ) |
Definition at line 1158 of file DialogUsageManager.cxx.
References resip::DialogSet::end(), and findDialogSet().
{
DialogSet* ds = findDialogSet(setid);
if (ds == 0)
{
throw Exception("Request no longer exists", __FILE__, __LINE__);
}
else
{
ds->end();
}
}
| AppDialogHandle DialogUsageManager::findAppDialog | ( | const DialogId & | id | ) |
Definition at line 1280 of file DialogUsageManager.cxx.
References findDialog(), resip::AppDialog::getHandle(), and resip::Dialog::mAppDialog.
{
Dialog* pDialog = findDialog(id);
if(pDialog && pDialog->mAppDialog)
{
return pDialog->mAppDialog->getHandle();
}
// Return an invalid handle
return AppDialogHandle();
}
| AppDialogSetHandle DialogUsageManager::findAppDialogSet | ( | const DialogSetId & | id | ) |
Definition at line 1293 of file DialogUsageManager.cxx.
References findDialogSet(), resip::AppDialogSet::getHandle(), and resip::DialogSet::mAppDialogSet.
{
DialogSet* pDialogSet = findDialogSet(id);
if(pDialogSet && pDialogSet->mAppDialogSet)
{
return pDialogSet->mAppDialogSet->getHandle();
}
// Return an invalid handle
return AppDialogSetHandle();
}
| BaseCreator * DialogUsageManager::findCreator | ( | const DialogId & | id | ) | [private] |
Definition at line 2278 of file DialogUsageManager.cxx.
References findDialogSet(), and resip::DialogSet::getCreator().
{
DialogSet* ds = findDialogSet(id.getDialogSetId());
if (ds)
{
return ds->getCreator();
}
else
{
return 0;
}
}
Definition at line 1212 of file DialogUsageManager.cxx.
References resip::DialogSet::findDialog(), and findDialogSet().
Referenced by findAppDialog(), findInviteSession(), and sendUsingOutboundIfAppropriate().
{
DialogSet* ds = findDialogSet(id.getDialogSetId());
if (ds)
{
return ds->findDialog(id);
}
else
{
return 0;
}
}
| DialogSet * DialogUsageManager::findDialogSet | ( | const DialogSetId & | id | ) | [private] |
Definition at line 2253 of file DialogUsageManager.cxx.
References resip::InserterP(), mDialogSetMap, StackLog, and threadCheck.
Referenced by end(), findAppDialogSet(), findCreator(), findDialog(), outgoingProcess(), processRequest(), processResponse(), and send().
{
threadCheck();
StackLog ( << "Looking for dialogSet: " << id << " in map:");
StackLog ( << "DialogSetMap: " << InserterP(mDialogSetMap) );
DialogSetMap::const_iterator it = mDialogSetMap.find(id);
if (it == mDialogSetMap.end())
{
return 0;
}
else
{
if(it->second->isDestroying())
{
return 0;
}
else
{
return it->second;
}
}
}
| InviteSessionHandle DialogUsageManager::findInviteSession | ( | DialogId | id | ) |
Definition at line 1227 of file DialogUsageManager.cxx.
References findDialog(), resip::InviteSession::getSessionHandle(), resip::Dialog::mInviteSession, and resip::Handle< InviteSession >::NotValid().
Referenced by findInviteSession(), and resip::BasicClientUserAgent::onNewSubscriptionFromRefer().
{
Dialog* dialog = findDialog(id);
if (dialog && dialog->mInviteSession)
{
return dialog->mInviteSession->getSessionHandle();
}
return InviteSessionHandle::NotValid();
}
| pair< InviteSessionHandle, int > DialogUsageManager::findInviteSession | ( | CallId | replaces | ) |
Definition at line 1239 of file DialogUsageManager.cxx.
References resip::CallID::exists(), findInviteSession(), resip::Handle< T >::isValid(), resip::Handle< InviteSession >::NotValid(), resip::ParserCategory::param(), and resip::CallID::value().
{
//486/481/603 decision making logic where? App may not wish to keep track of
//invitesession state
//Logic is here for now.
InviteSessionHandle is = findInviteSession(DialogId(replaces.value(),
replaces.param(p_toTag),
replaces.param(p_fromTag)));
int ErrorStatusCode = 481; // Call/Transaction Does Not Exist
// If we matched a session - Do RFC3891 Section 3 Processing
if(is.isValid())
{
// Note some missing checks are:
// 1. If the Replaces header field matches more than one dialog, the UA must act as
// if no match was found
// 2. Verify that the initiator of the new Invite is authorized
if(is->isTerminated())
{
ErrorStatusCode = 603; // Declined
is = InviteSessionHandle::NotValid();
}
else if(is->isConnected())
{
// Check if early-only flag is present in replaces header
if(replaces.exists(p_earlyOnly))
{
ErrorStatusCode = 486; // Busy Here
is = InviteSessionHandle::NotValid();
}
}
else if(!is->isEarly())
{
// replaces can't be used on early dialogs that were not initiated by this UA - ie. InviteSession::Proceeding state
ErrorStatusCode = 481; // Call/Transaction Does Not Exist
is = InviteSessionHandle::NotValid();
}
}
return make_pair(is, ErrorStatusCode);
}
| Dialog& resip::DialogUsageManager::findOrCreateDialog | ( | const SipMessage * | msg | ) | [private] |
| void DialogUsageManager::forceShutdown | ( | DumShutdownHandler * | h | ) |
Definition at line 284 of file DialogUsageManager.cxx.
References resip::HandleManager::dumpHandles(), mDumShutdownHandler, mShutdownState, onAllHandlesDestroyed(), ShutdownRequested, and WarningLog.
{
WarningLog (<< "force shutdown ");
dumpHandles();
mDumShutdownHandler = h;
//HandleManager::shutdown(); // clear out usages
mShutdownState = ShutdownRequested;
DialogUsageManager::onAllHandlesDestroyed();
}
| ClientPublicationHandler * DialogUsageManager::getClientPublicationHandler | ( | const Data & | eventType | ) |
Definition at line 2333 of file DialogUsageManager.cxx.
References mClientPublicationHandlers.
Referenced by resip::ClientPublication::dispatch().
{
map<Data, ClientPublicationHandler*>::iterator res = mClientPublicationHandlers.find(eventType);
if (res != mClientPublicationHandlers.end())
{
return res->second;
}
else
{
return 0;
}
}
| ClientSubscriptionHandler * DialogUsageManager::getClientSubscriptionHandler | ( | const Data & | eventType | ) |
Definition at line 2305 of file DialogUsageManager.cxx.
References mClientSubscriptionHandlers.
Referenced by checkEventPackage(), resip::ClientSubscription::dialogDestroyed(), resip::Dialog::dispatch(), resip::ClientSubscription::dispatch(), resip::ClientSubscription::flowTerminated(), resip::ClientSubscription::onReadyToSend(), resip::ClientSubscription::processNextNotify(), resip::ClientSubscription::processResponse(), and resip::ClientSubscription::rejectUpdate().
{
map<Data, ClientSubscriptionHandler*>::iterator res = mClientSubscriptionHandlers.find(eventType);
if (res != mClientSubscriptionHandlers.end())
{
return res->second;
}
else
{
return 0;
}
}
| Data DialogUsageManager::getHostAddress | ( | ) |
Definition at line 237 of file DialogUsageManager.cxx.
References resip::SipStack::getHostAddress(), and mStack.
{
return mStack.getHostAddress();
}
| SharedPtr< MasterProfile > & DialogUsageManager::getMasterProfile | ( | ) |
Definition at line 301 of file DialogUsageManager.cxx.
References resip::SharedPtr< T >::get(), and mMasterProfile.
Referenced by resip::ServerOutOfDialogReq::answerOptions(), resip::ServerRegistration::dispatch(), resip::InviteSession::handleSessionTimerRequest(), resip::InviteSession::handleSessionTimerResponse(), incomingProcess(), resip::InviteSessionCreator::InviteSessionCreator(), resip::InviteSession::isReliable(), main(), resip::BaseCreator::makeInitialRequest(), makeRegistration(), resip::Dialog::makeRequest(), resip::Dialog::makeResponse(), makeSubscription(), mergeRequest(), resip::ServerRegistration::processRegistration(), processRequest(), resip::ClientRegistration::tagContact(), resip::InviteSession::updateMethodSupported(), validate100RelSuport(), validateAccept(), validateContent(), validateRequestURI(), and validateRequiredOptions().
{
assert(mMasterProfile.get());
return mMasterProfile;
}
| SharedPtr< UserProfile > & DialogUsageManager::getMasterUserProfile | ( | ) |
Definition at line 308 of file DialogUsageManager.cxx.
References resip::SharedPtr< T >::get(), and mMasterUserProfile.
Referenced by resip::DialogSet::getUserProfile(), makeInviteSession(), makeInviteSessionFromRefer(), makeOutOfDialogRequest(), makePagerMessage(), makePublication(), makeRefer(), makeRegistration(), makeSubscription(), outgoingProcess(), resip::AppDialogSet::selectUASUserProfile(), and send().
{
assert(mMasterUserProfile.get());
return mMasterUserProfile;
}
| Message* resip::DialogUsageManager::getNext | ( | int | ms | ) | [inline] |
Definition at line 340 of file DialogUsageManager.hxx.
References resip::TimeLimitFifo< Msg >::getNext(), and resip::TransactionUser::mFifo.
{ return mFifo.getNext(ms); }
| OutOfDialogHandler * DialogUsageManager::getOutOfDialogHandler | ( | const MethodTypes | type | ) | [private] |
Definition at line 2361 of file DialogUsageManager.cxx.
References mOutOfDialogHandlers.
Referenced by resip::ServerOutOfDialogReq::dispatch(), and resip::ClientOutOfDialogReq::dispatch().
{
map<MethodTypes, OutOfDialogHandler*>::iterator res = mOutOfDialogHandlers.find(type);
if (res != mOutOfDialogHandlers.end())
{
return res->second;
}
else
{
return 0;
}
}
| RedirectHandler * DialogUsageManager::getRedirectHandler | ( | ) |
Definition at line 337 of file DialogUsageManager.cxx.
References mRedirectHandler.
Referenced by resip::RedirectManager::handle().
{
return mRedirectHandler;
}
| Security * DialogUsageManager::getSecurity | ( | ) |
Definition at line 231 of file DialogUsageManager.cxx.
References resip::SipStack::getSecurity(), and mStack.
Referenced by resip::ServerPublication::dispatch(), resip::IdentityHandler::processIdentityCheckResponse(), and resip::IdentityHandler::queueForIdentityCheck().
{
return mStack.getSecurity();
}
| ServerPublicationHandler * DialogUsageManager::getServerPublicationHandler | ( | const Data & | eventType | ) |
Definition at line 2347 of file DialogUsageManager.cxx.
References mServerPublicationHandlers.
Referenced by checkEventPackage(), and resip::ServerPublication::dispatch().
{
map<Data, ServerPublicationHandler*>::iterator res = mServerPublicationHandlers.find(eventType);
if (res != mServerPublicationHandlers.end())
{
return res->second;
}
else
{
return 0;
}
}
| ServerSubscriptionHandler * DialogUsageManager::getServerSubscriptionHandler | ( | const Data & | eventType | ) |
Definition at line 2319 of file DialogUsageManager.cxx.
References mServerSubscriptionHandlers.
Referenced by checkEventPackage(), resip::ServerSubscription::dialogDestroyed(), resip::ServerSubscription::dispatch(), resip::ServerSubscription::flowTerminated(), resip::ServerSubscription::onReadyToSend(), resip::ServerSubscription::send(), and resip::ServerPublication::updateMatchingSubscriptions().
{
map<Data, ServerSubscriptionHandler*>::iterator res = mServerSubscriptionHandlers.find(eventType);
if (res != mServerSubscriptionHandlers.end())
{
return res->second;
}
else
{
return 0;
}
}
| SipStack & DialogUsageManager::getSipStack | ( | ) |
Definition at line 219 of file DialogUsageManager.cxx.
References mStack.
Referenced by resip::ServerRegistration::accept(), resip::ClientRegistration::searchByUri(), and resip::ClientRegistration::tagContact().
{
return mStack;
}
| const SipStack & DialogUsageManager::getSipStack | ( | ) | const |
| bool DialogUsageManager::hasEvents | ( | ) | const |
Definition at line 1664 of file DialogUsageManager.cxx.
References resip::AbstractFifo< T >::messageAvailable(), and resip::TransactionUser::mFifo.
{
return mFifo.messageAvailable();
}
| void DialogUsageManager::incomingProcess | ( | std::auto_ptr< Message > | msg | ) | [private] |
Definition at line 1498 of file DialogUsageManager.cxx.
References resip::Data::append(), resip::DumFeatureChain::ChainDoneBit, DebugLog, resip::Data::Empty, ErrLog, resip::DumFeatureChain::EventTakenBit, getMasterProfile(), resip::BaseException::getMessage(), resip::SipMessage::getTransactionId(), resip::DumFeatureMessage::getTransactionId(), h_CallId, h_RequestLine, resip::SipMessage::header(), InfoLog, resip::SipMessage::isRequest(), resip::LazyParser::isWellFormed(), makeResponse(), mergeRequest(), resip::SipMessage::method(), resip::RequestLine::method(), mIncomingFeatureChainMap, mIncomingFeatureList, mIncomingTarget, processRequest(), processResponse(), sendResponse(), validate100RelSuport(), validateAccept(), validateContent(), validateRequestURI(), and validateRequiredOptions().
Referenced by internalProcess(), and resip::DialogUsageManager::IncomingTarget::post().
{
//call or create feature chain if appropriate
Data tid = Data::Empty;
{
SipMessage* sipMsg = dynamic_cast<SipMessage*>(msg.get());
if (sipMsg)
{
tid = sipMsg->getTransactionId();
bool garbage=false;
Data reason;
if(!sipMsg->header(h_From).isWellFormed())
{
garbage=true;
reason.append("Malformed From, ",16);
}
if(!sipMsg->header(h_To).isWellFormed())
{
garbage=true;
reason.append("Malformed To, ",14);
}
if(!sipMsg->header(h_CallId).isWellFormed())
{
garbage=true;
reason.append("Malformed Call-Id, ",19);
}
if(garbage)
{
if(sipMsg->isRequest() && sipMsg->method()!=ACK)
{
// .bwc. Either we need to trim the last comma off, or make this
// a proper sentence fragment. This is more fun.
reason.append("fix your code!",14);
SipMessage failure;
makeResponse(failure, *sipMsg, 400, reason);
sendResponse(failure);
}
InfoLog (<< "Malformed header in message (" << reason << ") - rejecting/discarding: " << *sipMsg);
// .bwc. Only forge a response when appropriate, but return in any
// case.
return;
}
}
DumFeatureMessage* featureMsg = dynamic_cast<DumFeatureMessage*>(msg.get());
if (featureMsg)
{
//DebugLog(<<"Got a DumFeatureMessage" << featureMsg);
tid = featureMsg->getTransactionId();
}
}
if (tid != Data::Empty && !mIncomingFeatureList.empty())
{
FeatureChainMap::iterator it;
//efficiently find or create FeatureChain, should prob. be a utility template
{
FeatureChainMap::iterator lb = mIncomingFeatureChainMap.lower_bound(tid);
if (lb != mIncomingFeatureChainMap.end() && !(mIncomingFeatureChainMap.key_comp()(tid, lb->first)))
{
it = lb;
}
else
{
assert(dynamic_cast<SipMessage*>(msg.get()));
it = mIncomingFeatureChainMap.insert(lb, FeatureChainMap::value_type(tid, new DumFeatureChain(*this, mIncomingFeatureList, *mIncomingTarget)));
}
}
DumFeatureChain::ProcessingResult res = it->second->process(msg.get());
if (res & DumFeatureChain::ChainDoneBit)
{
delete it->second;
mIncomingFeatureChainMap.erase(it);
//DebugLog(<< "feature chain deleted" << endl);
}
if (res & DumFeatureChain::EventTakenBit)
{
msg.release();
//DebugLog(<< "event taken");
return;
}
}
try
{
InfoLog (<< "Got: " << msg->brief());
DumDecrypted* decryptedMsg = dynamic_cast<DumDecrypted*>(msg.get());
SipMessage* sipMsg = 0;
if (decryptedMsg)
{
sipMsg = decryptedMsg->decrypted();
}
else
{
sipMsg = dynamic_cast<SipMessage*>(msg.get());
}
if (sipMsg)
{
//DebugLog ( << "DialogUsageManager::process: " << sipMsg->brief());
if (sipMsg->isRequest())
{
// Validate Request URI
if( !validateRequestURI(*sipMsg) )
{
DebugLog (<< "Failed RequestURI validation " << *sipMsg);
return;
}
// Continue validation on all requests, except ACK and CANCEL
if(sipMsg->header(h_RequestLine).method() != ACK &&
sipMsg->header(h_RequestLine).method() != CANCEL)
{
if( !validateRequiredOptions(*sipMsg) )
{
DebugLog (<< "Failed required options validation " << *sipMsg);
return;
}
if( !validate100RelSuport(*sipMsg) )
{
DebugLog (<< "Remote party does not support 100rel " << *sipMsg);
return;
}
if( getMasterProfile()->validateContentEnabled() && !validateContent(*sipMsg) )
{
DebugLog (<< "Failed content validation " << *sipMsg);
return;
}
if( getMasterProfile()->validateAcceptEnabled() && !validateAccept(*sipMsg) )
{
DebugLog (<< "Failed accept validation " << *sipMsg);
return;
}
}
if (sipMsg->header(h_From).exists(p_tag))
{
if (mergeRequest(*sipMsg) )
{
InfoLog (<< "Merged request: " << *sipMsg);
return;
}
}
processRequest(*sipMsg);
}
else
{
processResponse(*sipMsg);
}
}
}
catch(BaseException& e)
{
//unparseable, bad 403 w/ 2543 trans it from FWD, etc
ErrLog(<<"Illegal message rejected: " << e.getMessage());
}
}
| void DialogUsageManager::internalProcess | ( | std::auto_ptr< Message > | msg | ) |
Definition at line 1307 of file DialogUsageManager.cxx.
References DebugLog, resip::DestroyUsage::destroy(), resip::EventDispatcher< E >::dispatch(), ErrLog, resip::DumCommand::executeCommand(), resip::DumTimeout::getBaseUsage(), resip::KeepAlivePong::getFlow(), resip::ConnectionTerminated::getFlow(), incomingProcess(), InfoLog, resip::Handle< T >::isValid(), mConnectionTerminatedEventDispatcher, mDialogSetMap, mDumShutdownHandler, resip::Tuple::mFlowKey, mHiddenThreadDebugKey, mKeepAliveManager, mShutdownState, mThreadDebugKey, resip::DumShutdownHandler::onDumCanBeDeleted(), processExternalMessage(), RemovingTransactionUser, Shutdown, threadCheck, resip::ThreadIf::tlsKeyCreate(), resip::ThreadIf::tlsSetValue(), resip::TransactionUserMessage::TransactionUserRemoved, and resip::TransactionUserMessage::type().
Referenced by process(), and resip::DumThread::thread().
{
#ifdef RESIP_DUM_THREAD_DEBUG
if(!mThreadDebugKey)
{
// .bwc. Probably means multiple threads are trying to give DUM cycles
// simultaneously.
assert(!mHiddenThreadDebugKey);
// No d'tor needed, since we're just going to use a pointer to this.
if(!ThreadIf::tlsKeyCreate(mThreadDebugKey, 0))
{
// .bwc. We really could pass anything here, but for the sake of
// passing a valid pointer, I have (completely arbitrarily) chosen a
// pointer to the DUM. All that matters is that this value is non-null
ThreadIf::tlsSetValue(mThreadDebugKey, this);
}
else
{
ErrLog(<< "ThreadIf::tlsKeyCreate() failed!");
}
}
#endif
threadCheck();
// After a Stack ShutdownMessage has been received, don't do anything else in dum
if (mShutdownState == Shutdown)
{
return;
}
{
TransactionUserMessage* tuMsg = dynamic_cast<TransactionUserMessage*>(msg.get());
if (tuMsg)
{
InfoLog (<< "TU unregistered ");
assert(mShutdownState == RemovingTransactionUser);
assert(tuMsg->type() == TransactionUserMessage::TransactionUserRemoved);
mShutdownState = Shutdown;
if (mDumShutdownHandler)
{
mDumShutdownHandler->onDumCanBeDeleted();
mDumShutdownHandler = 0; // prevent mDumShutdownHandler getting called more than once
}
return;
}
}
{
KeepAlivePong* pong = dynamic_cast<KeepAlivePong*>(msg.get());
if (pong)
{
DebugLog(<< "keepalive pong received from " << pong->getFlow());
if (mKeepAliveManager.get())
{
mKeepAliveManager->receivedPong(pong->getFlow());
}
return;
}
}
{
DestroyUsage* destroyUsage = dynamic_cast<DestroyUsage*>(msg.get());
if (destroyUsage)
{
//DebugLog(<< "Destroying usage" );
destroyUsage->destroy();
return;
}
}
{
DumTimeout* dumMsg = dynamic_cast<DumTimeout*>(msg.get());
if (dumMsg)
{
//DebugLog(<< "Timeout Message" );
if (!dumMsg->getBaseUsage().isValid())
{
return;
}
dumMsg->getBaseUsage()->dispatch(*dumMsg);
return;
}
}
{
KeepAliveTimeout* keepAliveMsg = dynamic_cast<KeepAliveTimeout*>(msg.get());
if (keepAliveMsg)
{
//DebugLog(<< "Keep Alive Message" );
if (mKeepAliveManager.get())
{
mKeepAliveManager->process(*keepAliveMsg);
}
return;
}
}
{
KeepAlivePongTimeout* keepAlivePongMsg = dynamic_cast<KeepAlivePongTimeout*>(msg.get());
if (keepAlivePongMsg)
{
//DebugLog(<< "Keep Alive Pong Message" );
if (mKeepAliveManager.get())
{
mKeepAliveManager->process(*keepAlivePongMsg);
}
return;
}
}
{
ConnectionTerminated* terminated = dynamic_cast<ConnectionTerminated*>(msg.get());
if (terminated)
{
// Notify all dialogSets, in case they need to react (ie. client outbound support)
// First find all applicable dialogsets, since flow token in user profile will
// be cleared by first dialogset we notify, then notify all dialogset's
std::list<DialogSet*> dialogSetsToNotify;
DialogSetMap::iterator it = mDialogSetMap.begin();
for(; it != mDialogSetMap.end(); it++)
{
if(it->second->mUserProfile->clientOutboundEnabled() &&
it->second->mUserProfile->getClientOutboundFlowTuple().mFlowKey == terminated->getFlow().mFlowKey && // Flow key is not part of Tuple operator=, check it first
it->second->mUserProfile->getClientOutboundFlowTuple() == terminated->getFlow())
{
if(it->second->getClientRegistration().isValid())
{
// ensure client registrations are notified first
dialogSetsToNotify.push_front(it->second);
}
else
{
dialogSetsToNotify.push_back(it->second);
}
}
}
// Now dispatch notification to all dialogsets found above
std::list<DialogSet*>::iterator it2 = dialogSetsToNotify.begin();
for(; it2 != dialogSetsToNotify.end();it2++)
{
(*it2)->flowTerminated(terminated->getFlow());
}
DebugLog(<< "connection terminated message");
if (mConnectionTerminatedEventDispatcher.dispatch(msg.get()))
{
msg.release();
}
return;
}
}
{
DumCommand* command = dynamic_cast<DumCommand*>(msg.get());
if (command)
{
//DebugLog(<< "DumCommand" );
command->executeCommand();
return;
}
}
{
ExternalMessageBase* externalMessage = dynamic_cast<ExternalMessageBase*>(msg.get());
if (externalMessage)
{
processExternalMessage(externalMessage);
return;
}
}
incomingProcess(msg);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Contents * | initialOffer, | ||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 554 of file DialogUsageManager.cxx.
References None.
Referenced by resip::BasicClientCall::initiateCall(), main(), makeInviteSession(), and resip::BasicClientCall::onFlowTerminated().
{
return makeInviteSession(target, userProfile, initialOffer, None, 0, appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| const Contents * | initialOffer, | ||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 560 of file DialogUsageManager.cxx.
References getMasterUserProfile(), makeInviteSession(), and None.
{
return makeInviteSession(target, getMasterUserProfile(), initialOffer, None, 0, appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Contents * | initialOffer, | ||
| EncryptionLevel | level, | ||
| const Contents * | alternative = 0, |
||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 566 of file DialogUsageManager.cxx.
References makeNewSession(), and resip::DumHelper::setOutgoingEncryptionLevel().
{
SharedPtr<SipMessage> inv = makeNewSession(new InviteSessionCreator(*this, target, userProfile, initialOffer, level, alternative), appDs);
DumHelper::setOutgoingEncryptionLevel(*inv, level);
return inv;
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| const Contents * | initialOffer, | ||
| EncryptionLevel | level, | ||
| const Contents * | alternative = 0, |
||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 579 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeInviteSession().
{
return makeInviteSession(target, getMasterUserProfile(), initialOffer, level, alternative, appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| InviteSessionHandle | sessionToReplace, | ||
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Contents * | initialOffer, | ||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 589 of file DialogUsageManager.cxx.
References resip::Handle< T >::isValid(), makeInviteSession(), resip::ParserCategory::param(), and resip::CallID::value().
{
SharedPtr<SipMessage> inv = makeInviteSession(target, userProfile, initialOffer, ads);
// add replaces header
assert(sessionToReplace.isValid());
if(sessionToReplace.isValid())
{
CallId replaces;
DialogId id = sessionToReplace->getDialogId();
replaces.value() = id.getCallId();
replaces.param(p_toTag) = id.getRemoteTag();
replaces.param(p_fromTag) = id.getLocalTag();
inv->header(h_Replaces) = replaces;
}
return inv;
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| InviteSessionHandle | sessionToReplace, | ||
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Contents * | initialOffer, | ||
| EncryptionLevel | level = None, |
||
| const Contents * | alternative = 0, |
||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 611 of file DialogUsageManager.cxx.
References resip::Handle< T >::isValid(), makeInviteSession(), resip::ParserCategory::param(), and resip::CallID::value().
{
SharedPtr<SipMessage> inv = makeInviteSession(target, userProfile, initialOffer, level, alternative, ads);
// add replaces header
assert(sessionToReplace.isValid());
if(sessionToReplace.isValid())
{
CallId replaces;
DialogId id = sessionToReplace->getDialogId();
replaces.value() = id.getCallId();
replaces.param(p_toTag) = id.getRemoteTag();
replaces.param(p_fromTag) = id.getLocalTag();
inv->header(h_Replaces) = replaces;
}
return inv;
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSession | ( | const NameAddr & | target, |
| InviteSessionHandle | sessionToReplace, | ||
| const Contents * | initialOffer, | ||
| EncryptionLevel | level = None, |
||
| const Contents * | alternative = 0, |
||
| AppDialogSet * | ads = 0 |
||
| ) |
Definition at line 635 of file DialogUsageManager.cxx.
References resip::Handle< T >::isValid(), makeInviteSession(), resip::ParserCategory::param(), and resip::CallID::value().
{
SharedPtr<SipMessage> inv = makeInviteSession(target, initialOffer, level, alternative, ads);
// add replaces header
assert(sessionToReplace.isValid());
if(sessionToReplace.isValid())
{
CallId replaces;
DialogId id = sessionToReplace->getDialogId();
replaces.value() = id.getCallId();
replaces.param(p_toTag) = id.getRemoteTag();
replaces.param(p_fromTag) = id.getLocalTag();
inv->header(h_Replaces) = replaces;
}
return inv;
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSessionFromRefer | ( | const SipMessage & | refer, |
| ServerSubscriptionHandle | serverSub, | ||
| const Contents * | initialOffer, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 658 of file DialogUsageManager.cxx.
References None.
Referenced by makeInviteSessionFromRefer().
{
return makeInviteSessionFromRefer(refer, serverSub, initialOffer, None, 0, appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSessionFromRefer | ( | const SipMessage & | refer, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Contents * | initialOffer, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 667 of file DialogUsageManager.cxx.
References empty, makeInviteSessionFromRefer(), and None.
{
ServerSubscriptionHandle empty;
return makeInviteSessionFromRefer(refer, userProfile, empty, initialOffer, None, 0, appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSessionFromRefer | ( | const SipMessage & | refer, |
| ServerSubscriptionHandle | serverSub, | ||
| const Contents * | initialOffer, | ||
| EncryptionLevel | level = None, |
||
| const Contents * | alternative = 0, |
||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 677 of file DialogUsageManager.cxx.
References getMasterUserProfile(), resip::Handle< T >::isValid(), and makeInviteSessionFromRefer().
{
return makeInviteSessionFromRefer(refer, serverSub.isValid() ? serverSub->mDialog.mDialogSet.getUserProfile() : getMasterUserProfile(), serverSub, initialOffer, level, alternative, appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeInviteSessionFromRefer | ( | const SipMessage & | refer, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| ServerSubscriptionHandle | serverSub, | ||
| const Contents * | initialOffer, | ||
| EncryptionLevel | level = None, |
||
| const Contents * | alternative = 0, |
||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 688 of file DialogUsageManager.cxx.
References DebugLog, resip::Uri::embedded(), resip::SipMessage::exists(), h_StatusLine, resip::Uri::hasEmbedded(), resip::SipMessage::header(), resip::Handle< T >::isValid(), makeNewSession(), resip::SipFrag::message(), resip::Uri::remove(), resip::Uri::removeEmbedded(), resip::DumHelper::setOutgoingEncryptionLevel(), resip::NameAddr::uri(), and resip::RequestLine::uri().
{
if (serverSub.isValid())
{
DebugLog(<< "implicit subscription");
//generate and send 100
SipFrag contents;
contents.message().header(h_StatusLine).statusCode() = 100;
contents.message().header(h_StatusLine).reason() = "Trying";
//will be cloned...ServerSub may not have the most efficient API possible
serverSub->setSubscriptionState(Active);
SharedPtr<SipMessage> notify = serverSub->update(&contents);
// mInviteSessionHandler->onReadyToSend(InviteSessionHandle::NotValid(), notify);
serverSub->send(notify);
}
//19.1.5
NameAddr target = refer.header(h_ReferTo);
target.uri().removeEmbedded();
target.uri().remove(p_method);
// !jf! this code assumes you have a UserProfile
SharedPtr<SipMessage> inv = makeNewSession(new InviteSessionCreator(*this,
target,
userProfile,
initialOffer, level, alternative, serverSub), appDs);
DumHelper::setOutgoingEncryptionLevel(*inv, level);
//could pass dummy target, then apply merge rules from 19.1.5...or
//makeNewSession would use rules from 19.1.5
if (refer.exists(h_ReferredBy))
{
inv->header(h_ReferredBy) = refer.header(h_ReferredBy);
}
const Uri& referTo = refer.header(h_ReferTo).uri();
//19.1.5
if (referTo.hasEmbedded() && referTo.embedded().exists(h_Replaces))
{
inv->header(h_Replaces) = referTo.embedded().header(h_Replaces);
}
return inv;
}
| SharedPtr< SipMessage > DialogUsageManager::makeNewSession | ( | BaseCreator * | creator, |
| AppDialogSet * | appDs | ||
| ) | [private] |
Definition at line 530 of file DialogUsageManager.cxx.
References resip::BaseCreator::getLastRequest(), and makeUacDialogSet().
Referenced by makeInviteSession(), makeInviteSessionFromRefer(), makeOutOfDialogRequest(), makePublication(), makeRefer(), makeRegistration(), and makeSubscription().
{
makeUacDialogSet(creator, appDs);
return creator->getLastRequest();
}
| SharedPtr< SipMessage > DialogUsageManager::makeOutOfDialogRequest | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const MethodTypes | meth, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 839 of file DialogUsageManager.cxx.
References makeNewSession().
Referenced by main().
{
return makeNewSession(new OutOfDialogReqCreator(*this, meth, target, userProfile), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeOutOfDialogRequest | ( | const NameAddr & | target, |
| const MethodTypes | meth, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 845 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new OutOfDialogReqCreator(*this, meth, target, getMasterUserProfile()), appDs);
}
| ClientPagerMessageHandle DialogUsageManager::makePagerMessage | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 851 of file DialogUsageManager.cxx.
References ClientPagerMessage, resip::ClientPagerMessage::getHandle(), makeUacDialogSet(), resip::DialogSet::mClientPagerMessage, and mClientPagerMessageHandler.
Referenced by main(), and makePagerMessage().
{
if (!mClientPagerMessageHandler)
{
throw DumException("Cannot send MESSAGE messages without a ClientPagerMessageHandler", __FILE__, __LINE__);
}
DialogSet* ds = makeUacDialogSet(new PagerMessageCreator(*this, target, userProfile), appDs);
ClientPagerMessage* cpm = new ClientPagerMessage(*this, *ds);
ds->mClientPagerMessage = cpm;
return cpm->getHandle();
}
| ClientPagerMessageHandle DialogUsageManager::makePagerMessage | ( | const NameAddr & | target, |
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 864 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makePagerMessage().
{
return makePagerMessage(target, getMasterUserProfile(), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makePublication | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Contents & | body, | ||
| const Data & | eventType, | ||
| UInt32 | expiresSeconds, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 818 of file DialogUsageManager.cxx.
References makeNewSession().
Referenced by main().
{
return makeNewSession(new PublicationCreator(*this, targetDocument, userProfile, body, eventType, expiresSeconds), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makePublication | ( | const NameAddr & | target, |
| const Contents & | body, | ||
| const Data & | eventType, | ||
| UInt32 | expiresSeconds, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 829 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new PublicationCreator(*this, targetDocument, getMasterUserProfile(), body, eventType, expiresSeconds), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeRefer | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const H_ReferTo::Type & | referTo, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 740 of file DialogUsageManager.cxx.
References makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, userProfile, referTo), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeRefer | ( | const NameAddr & | target, |
| const H_ReferTo::Type & | referTo, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 746 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, getMasterUserProfile(), referTo), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeRegistration | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 793 of file DialogUsageManager.cxx.
References resip::SharedPtr< T >::get(), and makeNewSession().
Referenced by main(), resip::UserAgent::startup(), and resip::BasicClientUserAgent::startup().
{
assert(userProfile.get());
return makeNewSession(new RegistrationCreator(*this, target, userProfile, userProfile->getDefaultRegistrationTime()), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeRegistration | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| UInt32 | registrationTime, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 800 of file DialogUsageManager.cxx.
References makeNewSession().
{
return makeNewSession(new RegistrationCreator(*this, target, userProfile, registrationTime), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeRegistration | ( | const NameAddr & | target, |
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 806 of file DialogUsageManager.cxx.
References getMasterProfile(), getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new RegistrationCreator(*this, target, getMasterUserProfile(), getMasterProfile()->getDefaultRegistrationTime()), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeRegistration | ( | const NameAddr & | target, |
| UInt32 | registrationTime, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 812 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new RegistrationCreator(*this, target, getMasterUserProfile(), registrationTime), appDs);
}
| void DialogUsageManager::makeResponse | ( | SipMessage & | response, |
| const SipMessage & | request, | ||
| int | responseCode, | ||
| const Data & | reason = Data::Empty |
||
| ) | const [private] |
Definition at line 537 of file DialogUsageManager.cxx.
References resip::SipMessage::isRequest().
Referenced by resip::ServerOutOfDialogReq::accept(), resip::ServerPagerMessage::accept(), resip::ServerRegistration::accept(), resip::ServerOutOfDialogReq::answerOptions(), checkEventPackage(), resip::ServerOutOfDialogReq::dispatch(), resip::ServerPagerMessage::dispatch(), resip::ServerRegistration::dispatch(), resip::DialogSet::dispatch(), incomingProcess(), mergeRequest(), processPublish(), resip::ServerRegistration::processRegistration(), processRequest(), resip::ServerPagerMessage::reject(), resip::ServerOutOfDialogReq::reject(), resip::ServerRegistration::reject(), resip::ServerRegistration::testFlowRequirements(), validate100RelSuport(), validateAccept(), validateContent(), validateRequestURI(), and validateRequiredOptions().
{
assert(request.isRequest());
Helper::makeResponse(response, request, responseCode, reason);
}
| SharedPtr< SipMessage > DialogUsageManager::makeSubscription | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Data & | eventType, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 752 of file DialogUsageManager.cxx.
References resip::SharedPtr< T >::get(), and makeNewSession().
Referenced by AddAor::executeCommand(), resip::BasicClientUserAgent::onSuccess(), resip::ClientSubscription::reSubscribe(), and resip::BasicClientUserAgent::startup().
{
assert(userProfile.get());
return makeNewSession(new SubscriptionCreator(*this, target, userProfile, eventType, userProfile->getDefaultSubscriptionTime()), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeSubscription | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Data & | eventType, | ||
| UInt32 | subscriptionTime, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 759 of file DialogUsageManager.cxx.
References makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, userProfile, eventType, subscriptionTime), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeSubscription | ( | const NameAddr & | target, |
| const SharedPtr< UserProfile > & | userProfile, | ||
| const Data & | eventType, | ||
| UInt32 | subscriptionTime, | ||
| int | refreshInterval, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 766 of file DialogUsageManager.cxx.
References makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, userProfile, eventType, subscriptionTime, refreshInterval), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeSubscription | ( | const NameAddr & | target, |
| const Data & | eventType, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 773 of file DialogUsageManager.cxx.
References getMasterProfile(), getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, getMasterUserProfile(), eventType, getMasterProfile()->getDefaultSubscriptionTime()), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeSubscription | ( | const NameAddr & | target, |
| const Data & | eventType, | ||
| UInt32 | subscriptionTime, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 779 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, getMasterUserProfile(), eventType, subscriptionTime), appDs);
}
| SharedPtr< SipMessage > DialogUsageManager::makeSubscription | ( | const NameAddr & | target, |
| const Data & | eventType, | ||
| UInt32 | subscriptionTime, | ||
| int | refreshInterval, | ||
| AppDialogSet * | appDs = 0 |
||
| ) |
Definition at line 786 of file DialogUsageManager.cxx.
References getMasterUserProfile(), and makeNewSession().
{
return makeNewSession(new SubscriptionCreator(*this, target, getMasterUserProfile(), eventType, subscriptionTime, refreshInterval), appDs);
}
| DialogSet * DialogUsageManager::makeUacDialogSet | ( | BaseCreator * | creator, |
| AppDialogSet * | appDs | ||
| ) | [private] |
Definition at line 505 of file DialogUsageManager.cxx.
References DialogSet, resip::DialogSet::getId(), resip::InserterP(), resip::DialogSet::mAppDialogSet, resip::AppDialogSet::mDialogSet, mDialogSetMap, mDumShutdownHandler, StackLog, and threadCheck.
Referenced by makeNewSession(), and makePagerMessage().
{
threadCheck();
if (mDumShutdownHandler)
{
throw DumException("Cannot create new sessions when DUM is shutting down.", __FILE__, __LINE__);
}
if (appDs == 0)
{
appDs = new AppDialogSet(*this);
}
DialogSet* ds = new DialogSet(creator, *this);
appDs->mDialogSet = ds;
ds->mAppDialogSet = appDs;
StackLog ( << "************* Adding DialogSet ***************: " << ds->getId());
//StackLog ( << "Before: " << InserterP(mDialogSetMap) );
mDialogSetMap[ds->getId()] = ds;
StackLog ( << "DialogSetMap: " << InserterP(mDialogSetMap) );
return ds;
}
| bool DialogUsageManager::mergeRequest | ( | const SipMessage & | request | ) | [private] |
Definition at line 1924 of file DialogUsageManager.cxx.
References getMasterProfile(), resip::SipMessage::header(), resip::SipMessage::isExternal(), resip::SipMessage::isRequest(), makeResponse(), mMergedRequests, and sendResponse().
Referenced by incomingProcess().
{
assert(request.isRequest());
assert(request.isExternal());
if (!request.header(h_To).exists(p_tag))
{
if (mMergedRequests.count(MergedRequestKey(request, getMasterProfile()->checkReqUriInMergeDetectionEnabled())))
{
SipMessage failure;
makeResponse(failure, request, 482, "Merged Request");
failure.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(failure);
return true;
}
}
return false;
}
| bool resip::DialogUsageManager::messageAvailable | ( | void | ) | [inline] |
Definition at line 342 of file DialogUsageManager.hxx.
References resip::AbstractFifo< T >::messageAvailable(), and resip::TransactionUser::mFifo.
{ return mFifo.messageAvailable(); }
| const Data & DialogUsageManager::name | ( | ) | const [protected, virtual] |
Implements resip::TransactionUser.
Definition at line 197 of file DialogUsageManager.cxx.
{
static Data n("DialogUsageManager");
return n;
}
| void DialogUsageManager::onAllHandlesDestroyed | ( | ) | [protected, virtual] |
Implements resip::HandleManager.
Definition at line 243 of file DialogUsageManager.cxx.
References InfoLog, mDumShutdownHandler, mShutdownState, mStack, RemovingTransactionUser, ShutdownRequested, and resip::SipStack::unregisterTransactionUser().
Referenced by forceShutdown().
{
if (mDumShutdownHandler)
{
switch (mShutdownState)
{
case ShutdownRequested:
InfoLog (<< "DialogUsageManager::onAllHandlesDestroyed: removing TU");
//assert(mHandleMap.empty());
mShutdownState = RemovingTransactionUser;
mStack.unregisterTransactionUser(*this);
break;
default:
break;
}
}
}
| void DialogUsageManager::outgoingProcess | ( | std::auto_ptr< Message > | msg | ) | [private] |
dcm! -- unique SharedPtr to auto_ptr conversion prob. a worthwhile
Definition at line 997 of file DialogUsageManager.cxx.
References resip::DumFeatureChain::ChainDoneBit, resip::Data::Empty, resip::DumFeatureChain::EventTakenBit, findDialogSet(), resip::SharedPtr< T >::get(), getMasterUserProfile(), resip::OutgoingEvent::getTransactionId(), resip::DumFeatureMessage::getTransactionId(), resip::DialogSet::getUserProfile(), InfoLog, mOutgoingFeatureChainMap, mOutgoingFeatureList, mOutgoingMessageInterceptor, mOutgoingTarget, resip::Helper::processStrictRoute(), sendResponse(), and sendUsingOutboundIfAppropriate().
Referenced by resip::DialogUsageManager::OutgoingTarget::post(), and send().
{
Data tid = Data::Empty;
{
OutgoingEvent* sipMsg = dynamic_cast<OutgoingEvent*>(message.get());
if (sipMsg)
{
tid = sipMsg->getTransactionId();
}
DumFeatureMessage* featureMsg = dynamic_cast<DumFeatureMessage*>(message.get());
if (featureMsg)
{
InfoLog(<<"Got a DumFeatureMessage" << featureMsg);
tid = featureMsg->getTransactionId();
}
}
if (tid == Data::Empty && mOutgoingMessageInterceptor.get())
{
mOutgoingMessageInterceptor->process(message.get());
return;
}
else if (tid != Data::Empty && !mOutgoingFeatureList.empty())
{
FeatureChainMap::iterator it;
//efficiently find or create FeatureChain, should prob. be a utility template
{
FeatureChainMap::iterator lb = mOutgoingFeatureChainMap.lower_bound(tid);
if (lb != mOutgoingFeatureChainMap.end() && !(mOutgoingFeatureChainMap.key_comp()(tid, lb->first)))
{
it = lb;
}
else
{
it = mOutgoingFeatureChainMap.insert(lb, FeatureChainMap::value_type(tid, new DumFeatureChain(*this, mOutgoingFeatureList, *mOutgoingTarget)));
}
}
DumFeatureChain::ProcessingResult res = it->second->process(message.get());
if (res & DumFeatureChain::ChainDoneBit)
{
delete it->second;
mOutgoingFeatureChainMap.erase(it);
}
if (res & DumFeatureChain::EventTakenBit)
{
message.release();
return;
}
}
OutgoingEvent* event = dynamic_cast<OutgoingEvent*>(message.get());
//assert(event);
//.dcm. a TID collision can cause a message to be delivered to a finished
//chain. This is probably because pseudorandom was being used on Win32.
if (event)
{
if (event->message()->isRequest())
{
DialogSet* ds = findDialogSet(DialogSetId(*event->message()));
UserProfile* userProfile;
if (ds == 0)
{
userProfile = getMasterUserProfile().get();
}
else
{
userProfile = ds->getUserProfile().get();
}
assert(userProfile);
//optimzation here. SharedPtr would have to be changed; would
//throw/assert if not unique.
std::auto_ptr<SipMessage> toSend(static_cast<SipMessage*>(event->message()->clone()));
// .bwc. Protect ourselves from garbage with an isWellFormed() check.
// (Code in Dialog doesn't check for well-formedness in the
// Record-Route stack, so bad stuff there can end up here)
if (event->message()->exists(h_Routes) &&
!event->message()->header(h_Routes).empty() &&
event->message()->header(h_Routes).front().isWellFormed() &&
!event->message()->header(h_Routes).front().uri().exists(p_lr))
{
Helper::processStrictRoute(*toSend);
sendUsingOutboundIfAppropriate(*userProfile, toSend);
}
else
{
sendUsingOutboundIfAppropriate(*userProfile, toSend);
}
}
else
{
sendResponse(*event->message());
}
}
}
| bool DialogUsageManager::process | ( | resip::Lockable * | mutex = NULL | ) |
Definition at line 1671 of file DialogUsageManager.cxx.
References resip::TimeLimitFifo< Msg >::getNext(), internalProcess(), resip::AbstractFifo< T >::messageAvailable(), resip::TransactionUser::mFifo, mHiddenThreadDebugKey, and mThreadDebugKey.
Referenced by resip::DumProcessHandler::handleProcessNotification(), main(), resip::UserAgent::process(), and resip::BasicClientUserAgent::process().
{
if (mFifo.messageAvailable())
{
resip::PtrLock lock(mutex);
#ifdef RESIP_DUM_THREAD_DEBUG
mThreadDebugKey=mHiddenThreadDebugKey;
#endif
internalProcess(std::auto_ptr<Message>(mFifo.getNext()));
#ifdef RESIP_DUM_THREAD_DEBUG
// .bwc. Thread checking is disabled if mThreadDebugKey is 0; if the app
// is using this mutex-locked process() call, we only enable thread-
// checking while the mutex is locked. Accesses from another thread while
// the mutex is not locked are probably intentional. However, if the app
// accesses the DUM inappropriately anyway, we'll probably detect it if
// it happens during the internalProcess() call.
mHiddenThreadDebugKey=mThreadDebugKey;
mThreadDebugKey=0;
#endif
}
return mFifo.messageAvailable();
}
| bool DialogUsageManager::process | ( | int | timeoutMs, |
| resip::Lockable * | mutex = NULL |
||
| ) |
Definition at line 1695 of file DialogUsageManager.cxx.
References resip::TimeLimitFifo< Msg >::getNext(), internalProcess(), resip::AbstractFifo< T >::messageAvailable(), resip::TransactionUser::mFifo, mHiddenThreadDebugKey, and mThreadDebugKey.
{
std::auto_ptr<Message> message;
if(timeoutMs == -1)
{
message.reset(mFifo.getNext());
}
else
{
message.reset(mFifo.getNext(timeoutMs));
}
if (message.get())
{
resip::PtrLock lock(mutex);
#ifdef RESIP_DUM_THREAD_DEBUG
mThreadDebugKey=mHiddenThreadDebugKey;
#endif
internalProcess(message);
#ifdef RESIP_DUM_THREAD_DEBUG
// .bwc. Thread checking is disabled if mThreadDebugKey is 0; if the app
// is using this mutex-locked process() call, we only enable thread-
// checking while the mutex is locked. Accesses from another thread while
// the mutex is not locked are probably intentional. However, if the app
// accesses the DUM inappropriately anyway, we'll probably detect it if
// it happens during the internalProcess() call.
mHiddenThreadDebugKey=mThreadDebugKey;
mThreadDebugKey=0;
#endif
}
return mFifo.messageAvailable();
}
| void DialogUsageManager::processExternalMessage | ( | ExternalMessageBase * | externalMessage | ) | [private] |
Definition at line 1483 of file DialogUsageManager.cxx.
References mExternalMessageHandlers.
Referenced by internalProcess().
{
bool handled = false;
for(std::vector<ExternalMessageHandler*>::iterator i = mExternalMessageHandlers.begin();
i != mExternalMessageHandlers.end(); ++i)
{
(*i)->onMessage(externalMessage, handled);
if (handled)
{
break;
}
}
}
| void resip::DialogUsageManager::processIdentityCheckResponse | ( | const HttpGetMessage & | msg | ) | [private] |
| void DialogUsageManager::processPublish | ( | const SipMessage & | publish | ) | [private] |
Definition at line 2150 of file DialogUsageManager.cxx.
References resip::Message::brief(), checkEventPackage(), resip::ServerPublication::dispatch(), resip::SipMessage::exists(), resip::SipMessage::getContents(), resip::Random::getCryptoRandomHex(), resip::SipMessage::header(), InfoLog, makeResponse(), mServerPublications, send(), and ServerPublication.
Referenced by processRequest().
{
if (!checkEventPackage(request))
{
InfoLog(<< "Rejecting request (unsupported package) " << request.brief());
return;
}
if (request.exists(h_SIPIfMatch))
{
ServerPublications::iterator i = mServerPublications.find(request.header(h_SIPIfMatch).value());
if (i != mServerPublications.end())
{
i->second->dispatch(request);
}
else
{
SharedPtr<SipMessage> response(new SipMessage);
makeResponse(*response, request, 412);
send(response);
}
}
else
{
Data etag = Random::getCryptoRandomHex(8);
while (mServerPublications.find(etag) != mServerPublications.end())
{
etag = Random::getCryptoRandomHex(8);
}
if (request.getContents())
{
ServerPublication* sp = new ServerPublication(*this, etag, request);
mServerPublications[etag] = sp;
sp->dispatch(request);
}
else
{
// per 3903 (sec 6.5), a PUB w/ no SIPIfMatch must have contents. .mjf.
SharedPtr<SipMessage> response(new SipMessage);
makeResponse(*response, request, 400);
send(response);
}
}
}
| void DialogUsageManager::processRequest | ( | const SipMessage & | request | ) | [private] |
Definition at line 1945 of file DialogUsageManager.cxx.
References resip::Message::brief(), checkEventPackage(), DebugLog, DialogSet, resip::DialogSet::dispatch(), findDialogSet(), resip::DialogSet::getId(), getMasterProfile(), resip::BaseException::getMessage(), resip::RequestLine::getMethod(), resip::SipMessage::getTransactionId(), h_RequestLine, resip::SipMessage::header(), InfoLog, resip::InserterP(), makeResponse(), resip::DialogSet::mAppDialogSet, mAppDialogSetFactory, MAX_METHODS, mCancelMap, mDialogSetMap, mDumShutdownHandler, resip::RequestLine::method(), mShutdownState, processPublish(), Running, sendResponse(), resip::DialogSet::setUserProfile(), ShutdownRequested, StackLog, and WarningLog.
Referenced by incomingProcess().
{
DebugLog ( << "DialogUsageManager::processRequest: " << request.brief());
if (mShutdownState != Running && mShutdownState != ShutdownRequested)
{
WarningLog (<< "Ignoring a request since we are shutting down " << request.brief());
SipMessage failure;
makeResponse(failure, request, 480, "UAS is shutting down");
sendResponse(failure);
return;
}
if (request.header(h_RequestLine).method() == PUBLISH)
{
processPublish(request);
return;
}
bool toTag = request.header(h_To).exists(p_tag);
if(request.header(h_RequestLine).getMethod() == REGISTER && toTag && getMasterProfile()->allowBadRegistrationEnabled())
{
toTag = false;
}
assert(mAppDialogSetFactory.get());
// !jf! note, the logic was reversed during ye great merge of March of Ought 5
if (toTag ||
findDialogSet(DialogSetId(request)))
{
switch (request.header(h_RequestLine).getMethod())
{
case REGISTER:
{
SipMessage failure;
makeResponse(failure, request, 400, "Registration requests can't have To: tags.");
failure.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(failure);
break;
}
default:
{
DialogSet* ds = findDialogSet(DialogSetId(request));
if (ds == 0)
{
if (request.header(h_RequestLine).method() != ACK)
{
SipMessage failure;
makeResponse(failure, request, 481);
failure.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
InfoLog (<< "Rejected request (which was in a dialog) " << request.brief());
sendResponse(failure);
}
else
{
InfoLog (<< "ACK doesn't match any dialog" << request.brief());
}
}
else
{
InfoLog (<< "Handling in-dialog request: " << request.brief());
ds->dispatch(request);
}
}
}
}
else
{
switch (request.header(h_RequestLine).getMethod())
{
case ACK:
DebugLog (<< "Discarding request: " << request.brief());
break;
case PRACK:
case BYE:
case UPDATE:
case INFO: // !rm! in an ideal world
{
SipMessage failure;
makeResponse(failure, request, 481);
failure.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(failure);
break;
}
case CANCEL:
{
// find the appropropriate ServerInvSession
CancelMap::iterator i = mCancelMap.find(request.getTransactionId());
if (i != mCancelMap.end())
{
i->second->dispatch(request);
}
else
{
InfoLog (<< "Received a CANCEL on a non-existent transaction ");
SipMessage failure;
makeResponse(failure, request, 481);
sendResponse(failure);
}
break;
}
case PUBLISH:
assert(false);
return;
case SUBSCRIBE:
if (!checkEventPackage(request))
{
InfoLog (<< "Rejecting request (unsupported package) "
<< request.brief());
return;
}
/*FALLTHRU*/
case NOTIFY : // handle unsolicited (illegal) NOTIFYs
case INVITE: // new INVITE
case REFER: // out-of-dialog REFER
//case INFO : // handle non-dialog (illegal) INFOs
case OPTIONS : // handle non-dialog OPTIONS
case MESSAGE :
case REGISTER:
{
{
DialogSetId id(request);
//cryptographically dangerous
if(mDialogSetMap.find(id) != mDialogSetMap.end())
{
// this can only happen if someone sends us a request with the same callid and from tag as one
// that is in the process of destroying - since this is bad endpoint behaviour - we will
// reject the request with a 400 response
SipMessage badrequest;
makeResponse(badrequest, request, 400);
badrequest.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(badrequest);
return;
}
}
if (mDumShutdownHandler)
{
SipMessage forbidden;
makeResponse(forbidden, request, 480);
forbidden.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(forbidden);
return;
}
try
{
DialogSet* dset = new DialogSet(request, *this);
StackLog ( << "*********** Calling AppDialogSetFactory *************: " << dset->getId());
AppDialogSet* appDs = mAppDialogSetFactory->createAppDialogSet(*this, request);
appDs->mDialogSet = dset;
dset->setUserProfile(appDs->selectUASUserProfile(request));
dset->mAppDialogSet = appDs;
StackLog ( << "************* Adding DialogSet ***************: " << dset->getId());
//StackLog ( << "Before: " << Inserter(mDialogSetMap) );
mDialogSetMap[dset->getId()] = dset;
StackLog ( << "DialogSetMap: " << InserterP(mDialogSetMap) );
dset->dispatch(request);
}
catch (BaseException& e)
{
SipMessage failure;
makeResponse(failure, request, 400, e.getMessage());
failure.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(failure);
}
break;
}
case RESPONSE:
case SERVICE:
assert(false);
break;
case UNKNOWN:
case MAX_METHODS:
assert(false);
break;
}
}
}
| void DialogUsageManager::processResponse | ( | const SipMessage & | response | ) | [private] |
Definition at line 2131 of file DialogUsageManager.cxx.
References resip::Message::brief(), DebugLog, resip::DialogSet::dispatch(), findDialogSet(), resip::SipMessage::header(), InfoLog, and resip::RequestLine::method().
Referenced by incomingProcess().
{
if (response.header(h_CSeq).method() != CANCEL)
{
DialogSet* ds = findDialogSet(DialogSetId(response));
if (ds)
{
DebugLog ( << "DialogUsageManager::processResponse: " << std::endl << std::endl << response.brief());
ds->dispatch(response);
}
else
{
InfoLog (<< "Throwing away stray response: " << std::endl << std::endl << response.brief());
}
}
}
| bool resip::DialogUsageManager::queueForIdentityCheck | ( | SipMessage * | msg | ) | [private] |
| void DialogUsageManager::registerForConnectionTermination | ( | Postable * | listener | ) |
Note: Implementations of Postable must delete the message passed via post.
Definition at line 2428 of file DialogUsageManager.cxx.
References resip::EventDispatcher< E >::addListener(), and mConnectionTerminatedEventDispatcher.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent().
{
mConnectionTerminatedEventDispatcher.addListener(listener);
}
| void DialogUsageManager::removeDialogSet | ( | const DialogSetId & | dsId | ) | [private] |
Definition at line 2292 of file DialogUsageManager.cxx.
References resip::InserterP(), mDialogSetMap, mRedirectManager, and StackLog.
Referenced by resip::DialogSet::~DialogSet().
{
StackLog ( << "************* Removing DialogSet ***************: " << dsId);
//StackLog ( << "Before: " << Inserter(mDialogSetMap) );
mDialogSetMap.erase(dsId);
StackLog ( << "DialogSetMap: " << InserterP(mDialogSetMap) );
if (mRedirectManager.get())
{
mRedirectManager->removeDialogSet(dsId);
}
}
| void DialogUsageManager::removeExternalMessageHandler | ( | ExternalMessageHandler * | handler | ) |
Definition at line 487 of file DialogUsageManager.cxx.
References mExternalMessageHandlers.
{
std::vector<ExternalMessageHandler*>::iterator found = std::find(mExternalMessageHandlers.begin(), mExternalMessageHandlers.end(), handler);
if (found != mExternalMessageHandlers.end())
{
mExternalMessageHandlers.erase(found);
}
}
| void DialogUsageManager::removeMergedRequest | ( | const MergedRequestKey & | key | ) | [private] |
Definition at line 2448 of file DialogUsageManager.cxx.
References DebugLog, and mMergedRequests.
Referenced by resip::MergedRequestRemovalCommand::executeCommand().
{
DebugLog(<< "Merged request removed");
mMergedRequests.erase(key);
}
| void DialogUsageManager::requestMergedRequestRemoval | ( | const MergedRequestKey & | key | ) | [private] |
Definition at line 2440 of file DialogUsageManager.cxx.
References DebugLog, mStack, resip::SipStack::postMS(), and resip::Timer::TF.
Referenced by resip::DialogSet::~DialogSet().
{
DebugLog(<< "Got merged request removal request");
MergedRequestRemovalCommand command(*this, key);
mStack.postMS(command, Timer::TF, this);
}
| void DialogUsageManager::send | ( | SharedPtr< SipMessage > | request | ) |
Definition at line 870 of file DialogUsageManager.cxx.
References DebugLog, resip::Data::empty(), resip::DialogSet::findDialog(), findDialogSet(), resip::SharedPtr< T >::get(), resip::Profile::getFixedTransportInterface(), resip::Profile::getFixedTransportPort(), resip::Dialog::getInviteSession(), getMasterUserProfile(), resip::Profile::getOutboundDecorator(), resip::Profile::getProxyRequires(), resip::Profile::getRportEnabled(), resip::Profile::getUserAgent(), resip::DialogSet::getUserProfile(), h_RequestLine, resip::Profile::hasProxyRequires(), resip::Profile::hasUserAgent(), resip::UserProfile::isAnonymous(), mClientAuthManager, mDialogEventStateManager, resip::DialogEventStateManager::onConfirmed(), resip::DialogEventStateManager::onTryingUac(), outgoingProcess(), and resip::SharedPtr< T >::reset().
Referenced by resip::ServerRegistration::accept(), resip::ServerRegistration::asyncProcessFinalContacts(), checkEventPackage(), resip::ServerOutOfDialogReq::dispatch(), resip::ServerPublication::dispatch(), resip::ServerPagerMessage::dispatch(), resip::ServerRegistration::dispatch(), resip::DialogSet::dispatch(), resip::DialogSet::end(), AddAor::executeCommand(), resip::DialogUsageManager::SendCommand::executeCommand(), resip::TlsPeerAuthManager::handle(), resip::ServerAuthManager::handle(), resip::DialogSet::handledByAuthOrRedirect(), resip::ServerAuthManager::handleUserAuthInfo(), resip::BasicClientCall::initiateCall(), resip::ServerAuthManager::issueChallenge(), main(), resip::BasicClientCall::onFlowTerminated(), resip::BasicClientUserAgent::onSuccess(), resip::ClientPagerMessage::pageFirstMsgQueued(), resip::ServerAuthManager::process(), processPublish(), resip::ServerRegistration::processRegistration(), resip::ServerRegistration::reject(), resip::ClientSubscription::reSubscribe(), resip::ServerOutOfDialogReq::send(), resip::ServerPagerMessage::send(), resip::ServerPublication::send(), resip::NonDialogUsage::send(), resip::ClientPublication::send(), resip::Dialog::send(), resip::UserAgent::startup(), resip::BasicClientUserAgent::startup(), and resip::ServerRegistration::testFlowRequirements().
{
// !slg! There is probably a more efficient way to get the userProfile here (pass it in?)
DialogSet* ds = findDialogSet(DialogSetId(*msg));
UserProfile* userProfile;
if (ds == 0)
{
userProfile = getMasterUserProfile().get();
}
else
{
userProfile = ds->getUserProfile().get();
}
assert(userProfile);
if (!userProfile->isAnonymous() && userProfile->hasUserAgent())
{
msg->header(h_UserAgent).value() = userProfile->getUserAgent();
}
if (userProfile->isAnonymous())
{
msg->remove(h_ReplyTo);
msg->remove(h_UserAgent);
msg->remove(h_Organization);
msg->remove(h_Server);
msg->remove(h_Subject);
msg->remove(h_InReplyTo);
msg->remove(h_CallInfos);
msg->remove(h_Warnings);
}
assert(userProfile);
if (msg->isRequest()
&& userProfile->hasProxyRequires()
&& msg->header(h_RequestLine).method() != ACK
&& msg->header(h_RequestLine).method() != CANCEL)
{
msg->header(h_ProxyRequires) = userProfile->getProxyRequires();
}
// .bwc. This is to avoid leaving extra copies of the decorator in msg,
// when the caller of this function holds onto the reference (and this
// happens quite often in DUM). I would prefer to refactor such that we
// are operating on a copy in this function, but this would require a lot
// of work on the DumFeatureChain stuff (or, require an extra copy on top
// of the one we're doing when we send the message to the stack, which
// would chew up a lot of extra cycles).
msg->clearOutboundDecorators();
// Add outbound decorator from userprofile - note: it is important that this is
// done before the call to mClientAuthManager->addAuthentication, since the ClientAuthManager
// will install outbound decorators and we want these to run after the user provided ones, in
// case a user provided decorator modifes the message body used in auth.
SharedPtr<MessageDecorator> outboundDecorator = userProfile->getOutboundDecorator();
if (outboundDecorator.get())
{
msg->addOutboundDecorator(std::auto_ptr<MessageDecorator>(outboundDecorator->clone()));
}
if (msg->isRequest())
{
// We may not need to call reset() if makeRequest is always used.
if (msg->header(h_RequestLine).method() != CANCEL &&
msg->header(h_RequestLine).method() != ACK &&
msg->exists(h_Vias))
{
msg->header(h_Vias).front().param(p_branch).reset();
}
if (msg->exists(h_Vias))
{
if(!userProfile->getRportEnabled())
{
msg->header(h_Vias).front().remove(p_rport);
}
int fixedTransportPort = userProfile->getFixedTransportPort();
if(fixedTransportPort != 0)
{
msg->header(h_Vias).front().sentPort() = fixedTransportPort;
}
const Data& fixedTransportInterface = userProfile->getFixedTransportInterface();
if(!fixedTransportInterface.empty())
{
msg->header(h_Vias).front().sentHost() = fixedTransportInterface;
}
}
if (mClientAuthManager.get() && msg->header(h_RequestLine).method() != ACK)
{
mClientAuthManager->addAuthentication(*msg);
}
if (msg->header(h_RequestLine).method() == INVITE)
{
if (ds != 0)
{
if (mDialogEventStateManager)
{
Dialog* d = ds->findDialog(*msg);
if (d != 0)
{
mDialogEventStateManager->onConfirmed(*d, d->getInviteSession());
}
else
{
mDialogEventStateManager->onTryingUac(*ds, *msg);
}
}
}
}
}
DebugLog (<< "SEND: " << std::endl << std::endl << *msg);
OutgoingEvent* event = new OutgoingEvent(msg);
outgoingProcess(auto_ptr<Message>(event));
}
| void DialogUsageManager::sendCommand | ( | SharedPtr< SipMessage > | request | ) |
Definition at line 990 of file DialogUsageManager.cxx.
References resip::TransactionUser::post().
{
SendCommand* s=new SendCommand(request, *this);
post(s);
}
| void DialogUsageManager::sendResponse | ( | const SipMessage & | response | ) | [private] |
Definition at line 547 of file DialogUsageManager.cxx.
References resip::SipMessage::isResponse(), mStack, and resip::SipStack::send().
Referenced by resip::DialogSet::dispatch(), resip::Dialog::dispatch(), incomingProcess(), mergeRequest(), outgoingProcess(), processRequest(), validate100RelSuport(), validateAccept(), validateContent(), validateRequestURI(), and validateRequiredOptions().
{
assert(response.isResponse());
mStack.send(response, this);
}
| void DialogUsageManager::sendUsingOutboundIfAppropriate | ( | UserProfile & | userProfile, |
| std::auto_ptr< SipMessage > | msg | ||
| ) | [private] |
Definition at line 1101 of file DialogUsageManager.cxx.
References resip::UserProfile::clientOutboundEnabled(), DebugLog, findDialog(), resip::Profile::getExpressOutboundAsRouteSetEnabled(), resip::Profile::getForceOutboundProxyOnAllRequestsEnabled(), resip::Profile::getOutboundProxy(), resip::Profile::hasOutboundProxy(), resip::UserProfile::mClientOutboundFlowTuple, resip::Tuple::mFlowKey, mStack, resip::SipStack::send(), resip::SipStack::sendTo(), and resip::NameAddr::uri().
Referenced by outgoingProcess().
{
//a little inefficient, branch parameter might be better
DialogId id(*msg);
if (userProfile.hasOutboundProxy() &&
(!findDialog(id) || userProfile.getForceOutboundProxyOnAllRequestsEnabled()))
{
DebugLog ( << "Using outbound proxy: "
<< userProfile.getOutboundProxy().uri()
<< " -> " << msg->brief());
if (userProfile.getExpressOutboundAsRouteSetEnabled())
{
// prepend the outbound proxy to the service route
msg->header(h_Routes).push_front(NameAddr(userProfile.getOutboundProxy().uri()));
if(userProfile.clientOutboundEnabled() && userProfile.mClientOutboundFlowTuple.mFlowKey != 0)
{
DebugLog ( << "Sending with client outbound flow tuple to express outbound" );
DebugLog ( << "Flow Tuple: " << userProfile.mClientOutboundFlowTuple << " and key: " << userProfile.mClientOutboundFlowTuple.mFlowKey);
mStack.sendTo(msg, userProfile.mClientOutboundFlowTuple, this);
}
else
{
DebugLog ( << "Sending to express outbound w/o flow tuple");
mStack.send(msg, this);
}
}
else
{
if(userProfile.clientOutboundEnabled() && userProfile.mClientOutboundFlowTuple.mFlowKey != 0)
{
DebugLog ( << "Sending to outbound (no express) with flow tuple");
mStack.sendTo(msg, userProfile.mClientOutboundFlowTuple, this);
}
else
{
DebugLog ( << "Sending to outbound uri");
mStack.sendTo(msg, userProfile.getOutboundProxy().uri(), this);
}
}
}
else
{
DebugLog (<< "Send: " << msg->brief());
if(userProfile.clientOutboundEnabled() && userProfile.mClientOutboundFlowTuple.mFlowKey != 0)
{
mStack.sendTo(msg, userProfile.mClientOutboundFlowTuple, this);
}
else
{
mStack.send(msg, this);
}
}
}
| void DialogUsageManager::setAppDialogSetFactory | ( | std::auto_ptr< AppDialogSetFactory > | factory | ) |
Definition at line 295 of file DialogUsageManager.cxx.
References mAppDialogSetFactory.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), and main().
{
mAppDialogSetFactory = factory;
}
| void DialogUsageManager::setClientAuthManager | ( | std::auto_ptr< ClientAuthManager > | client | ) |
If there is no ClientAuthManager, when the client receives a 401/407, pass it up through the normal BaseUsageHandler.
Definition at line 343 of file DialogUsageManager.cxx.
References mClientAuthManager.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), main(), RegEventClient::RegEventClient(), and resip::UserAgent::UserAgent().
{
mClientAuthManager = manager;
}
| void DialogUsageManager::setClientPagerMessageHandler | ( | ClientPagerMessageHandler * | handler | ) |
Definition at line 465 of file DialogUsageManager.cxx.
References mClientPagerMessageHandler.
Referenced by main().
{
mClientPagerMessageHandler = handler;
}
| void DialogUsageManager::setClientRegistrationHandler | ( | ClientRegistrationHandler * | handler | ) |
If there is no such handler, calling makeRegistration will throw.
Definition at line 355 of file DialogUsageManager.cxx.
References mClientRegistrationHandler.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), main(), RegEventClient::RegEventClient(), and resip::UserAgent::UserAgent().
{
assert(!mClientRegistrationHandler);
mClientRegistrationHandler = handler;
}
| void DialogUsageManager::setDialogSetHandler | ( | DialogSetHandler * | handler | ) |
Definition at line 369 of file DialogUsageManager.cxx.
References mDialogSetHandler.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent().
{
mDialogSetHandler = handler;
}
| void DialogUsageManager::setInviteSessionHandler | ( | InviteSessionHandler * | handler | ) |
If there is no such handler, calling makeInviteSession will throw and receiving an INVITE as a UAS will respond with 405 Method Not Allowed.
Definition at line 375 of file DialogUsageManager.cxx.
References mInviteSessionHandler.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), main(), and resip::UserAgent::UserAgent().
{
assert(!mInviteSessionHandler);
mInviteSessionHandler = handler;
}
| void DialogUsageManager::setKeepAliveManager | ( | std::auto_ptr< KeepAliveManager > | keepAlive | ) |
Definition at line 321 of file DialogUsageManager.cxx.
References mKeepAliveManager.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), and main().
{
mKeepAliveManager = manager;
mKeepAliveManager->setDialogUsageManager(this);
}
| void DialogUsageManager::setMasterProfile | ( | const SharedPtr< MasterProfile > & | masterProfile | ) |
Definition at line 314 of file DialogUsageManager.cxx.
References resip::SharedPtr< T >::get(), mMasterProfile, and mMasterUserProfile.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent(), main(), RegEventClient::RegEventClient(), and resip::UserAgent::UserAgent().
{
assert(!mMasterProfile.get());
mMasterProfile = masterProfile;
mMasterUserProfile = masterProfile; // required so that we can return a reference to SharedPtr<UserProfile> in getMasterUserProfile
}
| void DialogUsageManager::setOutgoingMessageInterceptor | ( | resip::SharedPtr< DumFeature > | feat | ) |
Definition at line 2388 of file DialogUsageManager.cxx.
References mOutgoingMessageInterceptor.
{
mOutgoingMessageInterceptor = feat;
}
| void DialogUsageManager::setRedirectHandler | ( | RedirectHandler * | handler | ) |
Definition at line 332 of file DialogUsageManager.cxx.
References mRedirectHandler.
Referenced by resip::BasicClientUserAgent::BasicClientUserAgent().
{
mRedirectHandler = handler;
}
| void DialogUsageManager::setRedirectManager | ( | std::auto_ptr< RedirectManager > | redirect | ) |
Definition at line 327 of file DialogUsageManager.cxx.
References mRedirectManager.
{
mRedirectManager = manager;
}
| void DialogUsageManager::setRegistrationPersistenceManager | ( | RegistrationPersistenceManager * | manager | ) |
Sets a manager to handle storage of registration state.
Definition at line 389 of file DialogUsageManager.cxx.
References mRegistrationPersistenceManager.
{
assert(!mRegistrationPersistenceManager);
mRegistrationPersistenceManager = manager;
}
| void resip::DialogUsageManager::setRemoteCertStore | ( | std::auto_ptr< RemoteCertStore > | store | ) |
| void DialogUsageManager::setRequestValidationHandler | ( | RequestValidationHandler * | handler | ) |
Definition at line 382 of file DialogUsageManager.cxx.
References mRequestValidationHandler.
Referenced by main().
{
assert(!mRequestValidationHandler);
mRequestValidationHandler = handler;
}
| void DialogUsageManager::setServerAuthManager | ( | resip::SharedPtr< ServerAuthManager > | server | ) |
If there is no ServerAuthManager, the server does not authenticate requests.
Definition at line 349 of file DialogUsageManager.cxx.
References mIncomingFeatureList.
{
mIncomingFeatureList.insert(mIncomingFeatureList.begin(), manager);
}
| void DialogUsageManager::setServerPagerMessageHandler | ( | ServerPagerMessageHandler * | handler | ) |
Definition at line 471 of file DialogUsageManager.cxx.
References mServerPagerMessageHandler.
Referenced by main().
{
mServerPagerMessageHandler = handler;
}
| void DialogUsageManager::setServerRegistrationHandler | ( | ServerRegistrationHandler * | handler | ) |
If no such handler, UAS will respond to REGISTER with 405 Method Not Allowed.
Definition at line 362 of file DialogUsageManager.cxx.
References mServerRegistrationHandler.
{
assert(!mServerRegistrationHandler);
mServerRegistrationHandler = handler;
}
| void DialogUsageManager::shutdown | ( | DumShutdownHandler * | h | ) |
Definition at line 263 of file DialogUsageManager.cxx.
References InfoLog, mDialogSetMap, mDumShutdownHandler, mShutdownState, mStack, resip::SipStack::requestTransactionUserShutdown(), ShutdownRequested, and resip::HandleManager::shutdownWhenEmpty().
Referenced by main(), and resip::BasicClientUserAgent::process().
{
InfoLog (<< "shutdown: dialogSets=" << mDialogSetMap.size());
mDumShutdownHandler = h;
mShutdownState = ShutdownRequested;
mStack.requestTransactionUserShutdown(*this);
shutdownWhenEmpty();
}
| void DialogUsageManager::unRegisterForConnectionTermination | ( | Postable * | listener | ) |
Definition at line 2434 of file DialogUsageManager.cxx.
References mConnectionTerminatedEventDispatcher, and resip::EventDispatcher< E >::removeListener().
{
mConnectionTerminatedEventDispatcher.removeListener(listener);
}
| bool DialogUsageManager::validate100RelSuport | ( | const SipMessage & | request | ) | [private] |
Definition at line 1795 of file DialogUsageManager.cxx.
References resip::Symbols::C100rel, resip::SipMessage::exists(), getMasterProfile(), resip::RequestLine::getMethod(), h_RequestLine, resip::SipMessage::header(), makeResponse(), mRequestValidationHandler, resip::RequestValidationHandler::on100RelNotSupportedByRemote(), resip::MasterProfile::Required, and sendResponse().
Referenced by incomingProcess().
{
if(request.header(h_RequestLine).getMethod() == INVITE)
{
if (getMasterProfile()->getUasReliableProvisionalMode() == MasterProfile::Required)
{
if (!((request.exists(h_Requires) && request.header(h_Requires).find(Token(Symbols::C100rel)))
|| (request.exists(h_Supporteds) && request.header(h_Supporteds).find(Token(Symbols::C100rel)))))
{
SipMessage failure;
makeResponse(failure, request, 421);
failure.header(h_Requires).push_back(Token(Symbols::C100rel));
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->on100RelNotSupportedByRemote(request);
return false;
}
}
}
return true;
}
| bool DialogUsageManager::validateAccept | ( | const SipMessage & | request | ) | [private] |
Definition at line 1879 of file DialogUsageManager.cxx.
References resip::Message::brief(), resip::SipMessage::exists(), getMasterProfile(), h_RequestLine, resip::SipMessage::header(), InfoLog, makeResponse(), resip::RequestLine::method(), mRequestValidationHandler, resip::RequestValidationHandler::onInvalidAccept(), and sendResponse().
Referenced by incomingProcess().
{
MethodTypes method = request.header(h_RequestLine).method();
// checks for Accept to comply with SFTF test case 216
if(request.exists(h_Accepts))
{
for (Mimes::const_iterator i = request.header(h_Accepts).begin();
i != request.header(h_Accepts).end(); i++)
{
if (getMasterProfile()->isMimeTypeSupported(method, *i))
{
return true; // Accept header passes validation if we support as least one of the mime types
}
}
}
// If no Accept header then application/sdp should be assumed for certain methods
else if(method == INVITE ||
method == OPTIONS ||
method == PRACK ||
method == UPDATE)
{
if (getMasterProfile()->isMimeTypeSupported(request.header(h_RequestLine).method(), Mime("application", "sdp")))
{
return true;
}
}
else
{
// Other method without an Accept Header
return true;
}
InfoLog (<< "Received unsupported mime types in accept header: " << request.brief());
SipMessage failure;
makeResponse(failure, request, 406);
failure.header(h_Accepts) = getMasterProfile()->getSupportedMimeTypes(method);
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidAccept(request);
return false;
}
| bool DialogUsageManager::validateContent | ( | const SipMessage & | request | ) | [private] |
Definition at line 1820 of file DialogUsageManager.cxx.
References resip::Message::brief(), resip::SipMessage::exists(), getMasterProfile(), h_RequestLine, resip::SipMessage::header(), InfoLog, resip::isEqualNoCase(), resip::LazyParser::isWellFormed(), makeResponse(), resip::RequestLine::method(), mRequestValidationHandler, resip::RequestValidationHandler::onInvalidContentEncoding(), resip::RequestValidationHandler::onInvalidContentLanguage(), resip::RequestValidationHandler::onInvalidContentType(), resip::Symbols::Optional, and sendResponse().
Referenced by incomingProcess().
{
// RFC3261 - 8.2.3
// Don't need to validate content headers if they are specified as optional in the content-disposition
if (!(request.exists(h_ContentDisposition) &&
request.header(h_ContentDisposition).isWellFormed() &&
request.header(h_ContentDisposition).exists(p_handling) &&
isEqualNoCase(request.header(h_ContentDisposition).param(p_handling), Symbols::Optional)))
{
if (request.exists(h_ContentType) && !getMasterProfile()->isMimeTypeSupported(request.header(h_RequestLine).method(), request.header(h_ContentType)))
{
InfoLog (<< "Received an unsupported mime type: " << request.header(h_ContentType) << " for " << request.brief());
SipMessage failure;
makeResponse(failure, request, 415);
failure.header(h_Accepts) = getMasterProfile()->getSupportedMimeTypes(request.header(h_RequestLine).method());
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidContentType(request);
return false;
}
if (request.exists(h_ContentEncoding) && !getMasterProfile()->isContentEncodingSupported(request.header(h_ContentEncoding)))
{
InfoLog (<< "Received an unsupported mime type: " << request.header(h_ContentEncoding) << " for " << request.brief());
SipMessage failure;
makeResponse(failure, request, 415);
failure.header(h_AcceptEncodings) = getMasterProfile()->getSupportedEncodings();
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidContentEncoding(request);
return false;
}
if (getMasterProfile()->validateContentLanguageEnabled() &&
request.exists(h_ContentLanguages) && !getMasterProfile()->isLanguageSupported(request.header(h_ContentLanguages)))
{
InfoLog (<< "Received an unsupported language: " << request.header(h_ContentLanguages).front() << " for " << request.brief());
SipMessage failure;
makeResponse(failure, request, 415);
failure.header(h_AcceptLanguages) = getMasterProfile()->getSupportedLanguages();
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidContentLanguage(request);
return false;
}
}
return true;
}
| bool DialogUsageManager::validateRequestURI | ( | const SipMessage & | request | ) | [private] |
Definition at line 1729 of file DialogUsageManager.cxx.
References resip::Message::brief(), getMasterProfile(), resip::RequestLine::getMethod(), h_RequestLine, resip::SipMessage::header(), InfoLog, makeResponse(), mRequestValidationHandler, resip::RequestValidationHandler::onInvalidMethod(), resip::RequestValidationHandler::onInvalidScheme(), resip::Uri::scheme(), sendResponse(), and resip::RequestLine::uri().
Referenced by incomingProcess().
{
// RFC3261 - 8.2.1
if (!getMasterProfile()->isMethodSupported(request.header(h_RequestLine).getMethod()))
{
InfoLog (<< "Received an unsupported method: " << request.brief());
SipMessage failure;
makeResponse(failure, request, 405);
failure.header(h_Allows) = getMasterProfile()->getAllowedMethods();
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidMethod(request);
return false;
}
// RFC3261 - 8.2.2
if (!getMasterProfile()->isSchemeSupported(request.header(h_RequestLine).uri().scheme()))
{
InfoLog (<< "Received an unsupported scheme: " << request.brief());
SipMessage failure;
makeResponse(failure, request, 416);
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidScheme(request);
return false;
}
return true;
}
| bool DialogUsageManager::validateRequiredOptions | ( | const SipMessage & | request | ) | [private] |
Definition at line 1766 of file DialogUsageManager.cxx.
References resip::Message::brief(), resip::ParserContainerBase::empty(), resip::SipMessage::exists(), getMasterProfile(), resip::RequestLine::getMethod(), h_RequestLine, resip::SipMessage::header(), InfoLog, makeResponse(), mRequestValidationHandler, resip::RequestValidationHandler::onInvalidRequiredOptions(), and sendResponse().
Referenced by incomingProcess().
{
// RFC 2162 - 8.2.2
if(request.exists(h_Requires) && // Don't check requires if method is ACK or CANCEL
(request.header(h_RequestLine).getMethod() != ACK ||
request.header(h_RequestLine).getMethod() != CANCEL))
{
Tokens unsupported = getMasterProfile()->getUnsupportedOptionsTags(request.header(h_Requires));
if (!unsupported.empty())
{
InfoLog (<< "Received an unsupported option tag(s): " << request.brief());
SipMessage failure;
makeResponse(failure, request, 420);
failure.header(h_Unsupporteds) = unsupported;
sendResponse(failure);
if(mRequestValidationHandler)
mRequestValidationHandler->onInvalidRequiredOptions(request);
return false;
}
}
return true;
}
| bool resip::DialogUsageManager::validateTo | ( | const SipMessage & | request | ) | [private] |
Friends And Related Function Documentation
friend class BaseUsage [friend] |
Definition at line 387 of file DialogUsageManager.hxx.
friend class ClientInviteSession [friend] |
Definition at line 376 of file DialogUsageManager.hxx.
friend class ClientOutOfDialogReq [friend] |
Definition at line 377 of file DialogUsageManager.hxx.
friend class ClientPagerMessage [friend] |
Definition at line 388 of file DialogUsageManager.hxx.
Referenced by makePagerMessage().
friend class ClientPublication [friend] |
Definition at line 378 of file DialogUsageManager.hxx.
friend class ClientRegistration [friend] |
Definition at line 379 of file DialogUsageManager.hxx.
friend class ClientSubscription [friend] |
Definition at line 380 of file DialogUsageManager.hxx.
friend class Dialog [friend] |
Definition at line 373 of file DialogUsageManager.hxx.
friend class DialogSet [friend] |
Definition at line 374 of file DialogUsageManager.hxx.
Referenced by makeUacDialogSet(), and processRequest().
friend class DumThread [friend] |
Definition at line 361 of file DialogUsageManager.hxx.
friend class InviteSession [friend] |
Definition at line 381 of file DialogUsageManager.hxx.
friend class KeepAliveAssociation [friend] |
Definition at line 390 of file DialogUsageManager.hxx.
friend class MergedRequestRemovalCommand [friend] |
Definition at line 393 of file DialogUsageManager.hxx.
friend class NetworkAssociation [friend] |
Definition at line 391 of file DialogUsageManager.hxx.
friend class ServerInviteSession [friend] |
Definition at line 382 of file DialogUsageManager.hxx.
friend class ServerOutOfDialogReq [friend] |
Definition at line 383 of file DialogUsageManager.hxx.
friend class ServerPagerMessage [friend] |
Definition at line 389 of file DialogUsageManager.hxx.
friend class ServerPublication [friend] |
Definition at line 384 of file DialogUsageManager.hxx.
Referenced by processPublish().
friend class ServerRegistration [friend] |
Definition at line 385 of file DialogUsageManager.hxx.
friend class ServerSubscription [friend] |
Definition at line 386 of file DialogUsageManager.hxx.
friend class TargetCommand::Target [friend] |
Definition at line 394 of file DialogUsageManager.hxx.
Member Data Documentation
std::auto_ptr<AppDialogSetFactory> resip::DialogUsageManager::mAppDialogSetFactory [private] |
Definition at line 529 of file DialogUsageManager.hxx.
Referenced by processRequest(), and setAppDialogSetFactory().
Definition at line 491 of file DialogUsageManager.hxx.
Referenced by resip::DialogSet::DialogSet(), processRequest(), and resip::DialogSet::~DialogSet().
std::auto_ptr<ClientAuthManager> resip::DialogUsageManager::mClientAuthManager [private] |
Definition at line 499 of file DialogUsageManager.hxx.
Referenced by resip::ClientRegistration::checkProfileRetry(), resip::ClientRegistration::dispatch(), resip::Dialog::dispatch(), resip::DialogSet::handledByAuthOrRedirect(), send(), setClientAuthManager(), and resip::DialogSet::~DialogSet().
Definition at line 521 of file DialogUsageManager.hxx.
Referenced by resip::ClientPagerMessage::dispatch(), makePagerMessage(), and setClientPagerMessageHandler().
std::map<Data, ClientPublicationHandler*> resip::DialogUsageManager::mClientPublicationHandlers [private] |
Definition at line 515 of file DialogUsageManager.hxx.
Referenced by addClientPublicationHandler(), and getClientPublicationHandler().
Definition at line 503 of file DialogUsageManager.hxx.
Referenced by resip::ClientRegistration::dispatch(), resip::ClientRegistration::flowTerminated(), and setClientRegistrationHandler().
std::map<Data, ClientSubscriptionHandler*> resip::DialogUsageManager::mClientSubscriptionHandlers [private] |
Definition at line 513 of file DialogUsageManager.hxx.
Referenced by addClientSubscriptionHandler(), and getClientSubscriptionHandler().
EventDispatcher<ConnectionTerminated> resip::DialogUsageManager::mConnectionTerminatedEventDispatcher [private] |
Definition at line 558 of file DialogUsageManager.hxx.
Referenced by internalProcess(), registerForConnectionTermination(), and unRegisterForConnectionTermination().
Definition at line 527 of file DialogUsageManager.hxx.
Referenced by createDialogEventStateManager(), resip::DialogSet::dispatch(), resip::InviteSession::dispatchBye(), resip::ServerInviteSession::dispatchCancel(), resip::ServerInviteSession::dispatchStart(), resip::DialogSet::end(), resip::DialogSet::handledByAuthOrRedirect(), resip::ClientInviteSession::handleRedirect(), resip::ClientInviteSession::onConnectedAspect(), resip::ClientInviteSession::onFailureAspect(), resip::ClientInviteSession::onProvisionalAspect(), resip::ServerInviteSession::redirect(), send(), resip::ServerInviteSession::sendAccept(), resip::InviteSession::sendBye(), and resip::ServerInviteSession::sendProvisional().
Definition at line 506 of file DialogUsageManager.hxx.
Referenced by resip::DialogSet::dispatch(), and setDialogSetHandler().
Definition at line 494 of file DialogUsageManager.hxx.
Referenced by applyToAllClientSubscriptions(), applyToAllServerSubscriptions(), findDialogSet(), internalProcess(), makeUacDialogSet(), processRequest(), removeDialogSet(), shutdown(), and ~DialogUsageManager().
Definition at line 532 of file DialogUsageManager.hxx.
Referenced by forceShutdown(), internalProcess(), makeUacDialogSet(), onAllHandlesDestroyed(), processRequest(), and shutdown().
std::vector<ExternalMessageHandler*> resip::DialogUsageManager::mExternalMessageHandlers [private] |
Definition at line 523 of file DialogUsageManager.hxx.
Referenced by addExternalMessageHandler(), clearExternalMessageHandler(), processExternalMessage(), and removeExternalMessageHandler().
Definition at line 556 of file DialogUsageManager.hxx.
Referenced by internalProcess(), and process().
Definition at line 369 of file DialogUsageManager.hxx.
Referenced by incomingProcess().
Definition at line 363 of file DialogUsageManager.hxx.
Referenced by addIncomingFeature(), incomingProcess(), and setServerAuthManager().
Definition at line 553 of file DialogUsageManager.hxx.
Referenced by DialogUsageManager(), dumIncomingTarget(), incomingProcess(), and ~DialogUsageManager().
Definition at line 502 of file DialogUsageManager.hxx.
Referenced by resip::ServerInviteSession::accept(), resip::ClientInviteSession::dispatch(), resip::Dialog::dispatch(), resip::InviteSession::dispatch(), resip::ServerInviteSession::dispatchAccepted(), resip::ServerInviteSession::dispatchAcceptedWaitingAnswer(), resip::ServerInviteSession::dispatchBye(), resip::InviteSession::dispatchBye(), resip::ServerInviteSession::dispatchCancel(), resip::InviteSession::dispatchCancel(), resip::ClientInviteSession::dispatchCancelled(), resip::InviteSession::dispatchConnected(), resip::ClientInviteSession::dispatchEarly(), resip::ClientInviteSession::dispatchEarlyWithAnswer(), resip::ClientInviteSession::dispatchEarlyWithOffer(), resip::InviteSession::dispatchGlare(), resip::InviteSession::dispatchInfo(), resip::InviteSession::dispatchMessage(), resip::InviteSession::dispatchPrack(), resip::ClientInviteSession::dispatchQueuedUpdate(), resip::InviteSession::dispatchReceivedReinviteSentOffer(), resip::InviteSession::dispatchReinviteNoOfferGlare(), resip::ClientInviteSession::dispatchSentAnswer(), resip::InviteSession::dispatchSentReinvite(), resip::InviteSession::dispatchSentReinviteNoOffer(), resip::InviteSession::dispatchSentUpdate(), resip::ClientInviteSession::dispatchSentUpdateEarly(), resip::ClientInviteSession::dispatchSentUpdateEarlyGlare(), resip::ClientInviteSession::dispatchStart(), resip::ServerInviteSession::dispatchStart(), resip::InviteSession::dispatchUnhandledInvite(), resip::ServerInviteSession::dispatchUnknown(), resip::ServerInviteSession::dispatchWaitingToHangup(), resip::InviteSession::dispatchWaitingToHangup(), resip::ServerInviteSession::dispatchWaitingToOffer(), resip::ServerInviteSession::dispatchWaitingToRequestOffer(), resip::InviteSession::dispatchWaitingToTerminate(), resip::ClientInviteSession::end(), resip::ServerInviteSession::end(), resip::InviteSession::end(), resip::InviteSession::flowTerminated(), resip::InviteSession::getLocalSdp(), resip::InviteSession::getOfferAnswer(), resip::InviteSession::getProposedRemoteSdp(), resip::InviteSession::getRemoteSdp(), resip::ClientInviteSession::handleAnswer(), resip::ClientInviteSession::handleOffer(), resip::ClientInviteSession::handleRedirect(), resip::InviteSession::hasLocalSdp(), resip::InviteSession::hasProposedRemoteSdp(), resip::InviteSession::hasRemoteSdp(), resip::InviteSession::InviteSession(), resip::ClientInviteSession::onConnectedAspect(), resip::ClientInviteSession::onFailureAspect(), resip::ClientInviteSession::onProvisionalAspect(), resip::InviteSession::onReadyToSend(), resip::ServerInviteSession::provideAnswer(), resip::ServerInviteSession::redirect(), resip::InviteSession::referNoSub(), resip::ClientInviteSession::reject(), resip::ServerInviteSession::reject(), and setInviteSessionHandler().
bool resip::DialogUsageManager::mIsDefaultServerReferHandler [private] |
Definition at line 519 of file DialogUsageManager.hxx.
Referenced by addServerSubscriptionHandler(), and ~DialogUsageManager().
std::auto_ptr<KeepAliveManager> resip::DialogUsageManager::mKeepAliveManager [private] |
Definition at line 518 of file DialogUsageManager.hxx.
Referenced by resip::NetworkAssociation::clear(), internalProcess(), setKeepAliveManager(), resip::NetworkAssociation::update(), and resip::NetworkAssociation::~NetworkAssociation().
Definition at line 496 of file DialogUsageManager.hxx.
Referenced by getMasterProfile(), and setMasterProfile().
Definition at line 497 of file DialogUsageManager.hxx.
Referenced by getMasterUserProfile(), and setMasterProfile().
Definition at line 488 of file DialogUsageManager.hxx.
Referenced by resip::DialogSet::DialogSet(), mergeRequest(), and removeMergedRequest().
Definition at line 370 of file DialogUsageManager.hxx.
Referenced by outgoingProcess().
Definition at line 364 of file DialogUsageManager.hxx.
Referenced by addOutgoingFeature(), and outgoingProcess().
Definition at line 366 of file DialogUsageManager.hxx.
Referenced by outgoingProcess(), and setOutgoingMessageInterceptor().
Definition at line 554 of file DialogUsageManager.hxx.
Referenced by DialogUsageManager(), dumOutgoingTarget(), outgoingProcess(), and ~DialogUsageManager().
std::map<MethodTypes, OutOfDialogHandler*> resip::DialogUsageManager::mOutOfDialogHandlers [private] |
Definition at line 517 of file DialogUsageManager.hxx.
Referenced by addOutOfDialogHandler(), and getOutOfDialogHandler().
Definition at line 505 of file DialogUsageManager.hxx.
Referenced by getRedirectHandler(), and setRedirectHandler().
std::auto_ptr<RedirectManager> resip::DialogUsageManager::mRedirectManager [private] |
Definition at line 498 of file DialogUsageManager.hxx.
Referenced by resip::DialogSet::handledByAuthOrRedirect(), removeDialogSet(), and setRedirectManager().
RegistrationPersistenceManager* resip::DialogUsageManager::mRegistrationPersistenceManager [private] |
Definition at line 509 of file DialogUsageManager.hxx.
Referenced by resip::ServerRegistration::accept(), resip::ServerRegistration::dispatch(), resip::ServerRegistration::processFinalOkMsg(), resip::ServerRegistration::processRegistration(), resip::ServerRegistration::reject(), and setRegistrationPersistenceManager().
Definition at line 507 of file DialogUsageManager.hxx.
Referenced by setRequestValidationHandler(), validate100RelSuport(), validateAccept(), validateContent(), validateRequestURI(), and validateRequiredOptions().
Definition at line 547 of file DialogUsageManager.hxx.
Definition at line 522 of file DialogUsageManager.hxx.
Referenced by resip::ServerPagerMessage::dispatch(), and setServerPagerMessageHandler().
std::map<Data, ServerPublicationHandler*> resip::DialogUsageManager::mServerPublicationHandlers [private] |
Definition at line 516 of file DialogUsageManager.hxx.
Referenced by addServerPublicationHandler(), and getServerPublicationHandler().
Definition at line 545 of file DialogUsageManager.hxx.
Referenced by processPublish(), and resip::ServerPublication::~ServerPublication().
Definition at line 504 of file DialogUsageManager.hxx.
Referenced by resip::ServerRegistration::accept(), resip::ServerRegistration::asyncProcessFinalOkMsg(), resip::ServerRegistration::dispatch(), resip::ServerRegistration::processRegistration(), resip::ServerRegistration::reject(), and setServerRegistrationHandler().
std::map<Data, ServerSubscriptionHandler*> resip::DialogUsageManager::mServerSubscriptionHandlers [private] |
Definition at line 514 of file DialogUsageManager.hxx.
Referenced by addServerSubscriptionHandler(), getServerSubscriptionHandler(), and ~DialogUsageManager().
Definition at line 551 of file DialogUsageManager.hxx.
Referenced by applyToServerSubscriptions(), resip::ServerSubscription::ServerSubscription(), resip::ServerPublication::updateMatchingSubscriptions(), and resip::ServerSubscription::~ServerSubscription().
Definition at line 541 of file DialogUsageManager.hxx.
Referenced by destroy(), forceShutdown(), internalProcess(), onAllHandlesDestroyed(), processRequest(), shutdown(), and ~DialogUsageManager().
SipStack& resip::DialogUsageManager::mStack [private] |
Definition at line 531 of file DialogUsageManager.hxx.
Referenced by addTimer(), addTimerMs(), addTransport(), DialogUsageManager(), getHostAddress(), getSecurity(), getSipStack(), onAllHandlesDestroyed(), requestMergedRequestRemoval(), sendResponse(), sendUsingOutboundIfAppropriate(), and shutdown().
Definition at line 555 of file DialogUsageManager.hxx.
Referenced by internalProcess(), and process().
The documentation for this class was generated from the following files:
