diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Server/src/CSipCSSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Server/src/CSipCSSession.cpp Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,595 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Name : CSipCSSession.cpp +// Part of : SIPServerCore +// Version : SIP/6.0 +// + + + +#include "CSipServerCore.h" +#include "CSipCSServer.h" +#include "CSipCSSession.h" +#include "CSipCSSessionReceiver.h" +#include "CSipCSServerITC.h" +#include "CSipCSSubSession.h" +#include "CTransactionUser.h" +#include "CSipDialogMgr.h" +#include "CSIPRegistrationMgr.h" +#include "sipheaderbase.h" +#include "MSigComp.h" +#include "SipRequestHandlerBase.h" +#include "SipAssert.h" +#include "sipsec.h" +#include "MSipRefreshMgr.h" + + +// ----------------------------------------------------------------------------- +// CSipCSSession::NewL +// ----------------------------------------------------------------------------- +// +CSipCSSession* CSipCSSession::NewL (CSipServerCore& aServerCore) + { + CSipCSSession* self = CSipCSSession::NewLC(aServerCore); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::NewLC +// ----------------------------------------------------------------------------- +// +CSipCSSession* CSipCSSession::NewLC (CSipServerCore& aServerCore) + { + CSipCSSession* self = new(ELeave)CSipCSSession(aServerCore); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::CSipCSSession +// ----------------------------------------------------------------------------- +// +CSipCSSession::CSipCSSession (CSipServerCore& aServerCore) + : iServerCore (aServerCore), + iByPassSIPSec(EFalse) + { + iServerCore.IncrementSessions(); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ConstructL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::ConstructL () + { + iReceiver = CSipCSSessionReceiver::NewL(iServerCore.ITC(),*this); + // second-phase construct base class + iSubSessions = iServerCore.ObjectConIx().CreateL(); + iSubSessionIndex = CObjectIx::NewL(); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::~CSipCSSession +// ----------------------------------------------------------------------------- +// +CSipCSSession::~CSipCSSession() + { + if (iReceiver) + { + iServerCore.TU().ClearTransactionOwner(iReceiver); + } + iServerCore.RequestHandler().Deregister(iClientUid); + delete iSubSessionIndex; + iServerCore.ObjectConIx().Remove(iSubSessions); + iSubSessions = 0; + delete iReceiver; + iServerCore.DecrementSessions(); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ITC +// ----------------------------------------------------------------------------- +// +CSipCSServerITC& CSipCSSession::ITC () + { + return iServerCore.ITC(); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ServerCore +// ----------------------------------------------------------------------------- +// +CSipServerCore& CSipCSSession::ServerCore () + { + return iServerCore; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::FindOwner +// From MSipCSSession +// ----------------------------------------------------------------------------- +// +MTransactionOwner& CSipCSSession::FindOwner(TUint32 aIapId) + { + MTransactionOwner* transactionOwner = iReceiver; + CSipCSSubSession* subSession = 0; + for (TInt i=0; i < iSubSessions->Count(); i++) + { + subSession = static_cast((*iSubSessions)[i]); + if (subSession->IapId() == aIapId) + { + transactionOwner = subSession->TransactionOwner(); + } + } + return *transactionOwner; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SIPSecUser +// From MSipCSSession +// ----------------------------------------------------------------------------- +// +const MSIPSecUser* CSipCSSession::SIPSecUser( + const TRegistrationId& aRegistrationId) + { + return ServerCore().RegistrationMgr().SIPSecUser(aRegistrationId); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ByPassSIPSec() +// From MSipCSSession +// ----------------------------------------------------------------------------- +// +TBool CSipCSSession::ByPassSIPSec() const + { + return iByPassSIPSec; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ServiceL +// From CSession +// ----------------------------------------------------------------------------- +// +void CSipCSSession::ServiceL (const RMessage2& aMessage) + { + DoServiceL(aMessage.Function(),aMessage); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::Uid +// ----------------------------------------------------------------------------- +// +TUid CSipCSSession::Uid () + { + return iClientUid; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ConnectionStateChangedL +// From MConnectionStateObserver: +// ----------------------------------------------------------------------------- +// +void CSipCSSession::ConnectionStateChangedL (TUint32 aIapId, + CSIPConnection::TState aState) + { + CSipCSSubSession* subSession = 0; + for (TInt i=0; i < iSubSessions->Count(); i++) + { + subSession = static_cast((*iSubSessions)[i]); + if (subSession->IapId() == aIapId) + { + subSession->SetStateL(aState); + } + } + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::DoServiceL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::DoServiceL (TInt aFunction, const RMessage2& aMessage) + { + switch (aFunction) + { +#ifndef PLAT_SEC_TEST + case ESipItcSetAppUid: + SetClientUidL (aMessage); break; + + case ESipItcSupportedSecurityMechanisms: + SupportedSecurityMechanismsL (aMessage); break; + + case ESipItcNegotiatedSecurityMechanism: + NegotiatedSecurityMechanismL (aMessage); break; + + case ESipItcSetHttpDigestObserver: + SetHttpDigestObserverL(aMessage); break; + + case ESipItcSetCredentials: + SetCredentialsL(aMessage); break; + + case ESipItcRemoveCredentials: + RemoveCredentialsL(aMessage); break; + + case ESipItcIgnoreChallenge: + IgnoreChallengeL(aMessage); break; + + case ESipItcSetSecurityHandling: + SetSecurityHandlingL(aMessage); break; + + case ESipItcIsSigCompSupported: + SigCompSupportedL (); break; + + case ESipItcGetTransactionState: + GetTransactionStateL (aMessage); break; + + case ESipItcGetDialogState: + GetDialogStateL (aMessage); break; + + case ESipItcGetCompartmentCount: + GetCompartmentCountL (aMessage); break; + + case ESipItcOpenSubSession: + { + TUint32 iapId = ITC().ReadSipIdsL(aMessage).iIapId; + OpenSubSessionL (iapId,aMessage); + } + break; + + case ESipItcCloseSubSession: + { + TInt handle = 0; + ITC().ReadL(aMessage,handle,ESipItcArgSubSessionHandle); + CloseSubSession (handle); + } + break; + + case ESipItcClientReadyToReceive: // Asynchronous. Do not complete yet. + ClientReadyToReceiveL (aMessage); return; + + case ESipItcClientReceiveSipMessage: + ReceiveSipMessageL (aMessage); break; + + case ESipItcClientCancelReceive: + CancelClientReceiveL (); break; + + default: + { + TInt handle = 0; + ITC().ReadL(aMessage,handle,ESipItcArgSubSessionHandle); + CallSubSessionL (handle, aMessage); + } + return; +#endif + } + ITC().Complete (aMessage, KErrNone); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SetClientUidL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::SetClientUidL (const RMessage2& aMessage) + { + iClientUid.iUid = ITC().ReadAppUidL (aMessage).iUid; + ServerCore().RequestHandler().RegisterL(iClientUid); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SupportedSecurityMechanismsL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::SupportedSecurityMechanismsL (const RMessage2& aMessage) + { + CDesC8Array* mechanisms = + ServerCore().SIPSec().SupportedSecurityMechanismsL(); + __SIP_ASSERT_LEAVE (mechanisms!=0,KErrArgument); + CleanupStack::PushL (mechanisms); + ITC().WriteL(aMessage,*mechanisms); + CleanupStack::PopAndDestroy(mechanisms); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::NegotiatedSecurityMechanismL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::NegotiatedSecurityMechanismL (const RMessage2& aMessage) + { + HBufC8* nextHop = ITC().ReadLC(aMessage,ESipItcArgNextHop); + HBufC8* mechanism = + ServerCore().SIPSec().NegotiatedSecurityMechanismL(*nextHop); + CleanupStack::PopAndDestroy(nextHop); + if (mechanism) + { + CleanupStack::PushL(mechanism); + ITC().WriteL(aMessage,*mechanism,ESipItcArgAuthenticationMechanism); + CleanupStack::PopAndDestroy(mechanism); + } + else + { + ITC().WriteL(aMessage,KNullDesC8,ESipItcArgAuthenticationMechanism); + } + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SetHttpDigestObserverL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::SetHttpDigestObserverL (const RMessage2& aMessage) + { + TInt observerType(0); + ITC().ReadL(aMessage,observerType,ESipItcArgHttpDigestObserverType); + iReceiver->SetHttpDigestObserver( + static_cast(observerType)); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SetCredentialsL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::SetCredentialsL (const RMessage2& aMessage) + { + HBufC8* realm = ITC().ReadLC(aMessage,ESipItcArgRealm); + + CDesC8Array* credentials = ITC().ReadCredentialsLC(aMessage); + TInt credentialsCount = credentials->MdcaCount(); + __ASSERT_ALWAYS(credentialsCount > 1, User::Leave(KErrArgument)); + TPtrC8 outboundproxy(KNullDesC8); + if (credentialsCount == EOutboundProxyIndex+1) + { + outboundproxy.Set(credentials->MdcaPoint(EOutboundProxyIndex)); + } + + TSIPIds ids = ITC().ReadSipIdsL(aMessage); + const MSIPSecUser* sipSecUser = + FindSIPSecUser(ids.iRefreshId,ids.iRequestId); + + if (sipSecUser) + { + ServerCore().SIPSec().SetCredentialsL( + *sipSecUser, + *realm, + outboundproxy, + credentials->MdcaPoint(EUserIndex), + credentials->MdcaPoint(EPasswdIndex)); + } + else + { + ServerCore().SIPSec().SetCredentialsL( + KEmptyTransactionId, + *realm, + outboundproxy, + credentials->MdcaPoint(EUserIndex), + credentials->MdcaPoint(EPasswdIndex)); + } + + CleanupStack::PopAndDestroy(credentials); + CleanupStack::PopAndDestroy(realm); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::RemoveCredentialsL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::RemoveCredentialsL (const RMessage2& aMessage) + { + HBufC8* realm = ITC().ReadLC(aMessage,ESipItcArgRealm); + User::LeaveIfError(ServerCore().SIPSec().RemoveCredentials(*realm)); + CleanupStack::PopAndDestroy(realm); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::IgnoreChallengeL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::IgnoreChallengeL (const RMessage2& aMessage) + { + HBufC8* realm = ITC().ReadLC(aMessage,ESipItcArgRealm); + TSIPIds ids = ITC().ReadSipIdsL(aMessage); + TTransactionId taId = ids.iRequestId; + const MSIPSecUser* sipSecUser = FindSIPSecUser(ids.iRefreshId,taId); + User::LeaveIfError( + ServerCore().SIPSec().IgnoreChallenge(taId,*realm,sipSecUser)); + CleanupStack::PopAndDestroy(realm); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SetSecurityHandlingL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::SetSecurityHandlingL(const RMessage2& aMessage) + { + TInt securityHandlingEnabled(0); + ITC().ReadL(aMessage,securityHandlingEnabled,ESipItcArgSecurityHandling); + iByPassSIPSec = !securityHandlingEnabled; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::SigCompSupportedL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::SigCompSupportedL () + { + if (!ServerCore().SigComp().IsSupported()) + { + User::Leave(KErrNotSupported); + } + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::GetTransactionStateL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::GetTransactionStateL (const RMessage2& aMessage) + { + TSIPIds ids = ITC().ReadSipIdsL(aMessage); + CSIPInternalStates::TState state; + ServerCore().TU().GetStateL(ids.iRequestId,state); + ITC().WriteL(aMessage,state,ESipItcArgInternalState); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::GetDialogStateL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::GetDialogStateL (const RMessage2& aMessage) + { + TSIPIds ids = ITC().ReadSipIdsL(aMessage); + CSIPInternalStates::TState state; + ServerCore().DialogMgr().GetStateL(ids.iDialogId,state); + ITC().WriteL(aMessage,state,ESipItcArgInternalState); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::GetCompartmentCountL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::GetCompartmentCountL (const RMessage2& aMessage) + { + TInt count = ServerCore().SigComp().CompartmentCount(); + ITC().WriteL(aMessage,count,ESipItcArgInternalState); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::OpenSubSessionL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::OpenSubSessionL (TUint32 aIapId, const RMessage2& aMessage) + { + TInt err; + if (Exists(aIapId)) + { + User::Leave(KErrAlreadyExists); + } + CSipCSSubSession* subSession = + CSipCSSubSession::NewLC(*this,*iReceiver,aIapId); + iReceiver->MovePendingErrorsL(aIapId,subSession->Receiver()); + iSubSessions->AddL(subSession); + TInt handle = iSubSessionIndex->AddL(subSession); + CleanupStack::Pop(); // subSession + TRAP (err, subSession->OpenIapL(aMessage)); + if (err) + { + iSubSessionIndex->Remove(handle); + User::Leave(err); + } + TRAP (err, ITC().WriteL(aMessage,handle,ESipItcArgSubSessionHandle)); + if (err) + { + iSubSessionIndex->Remove(handle); + User::Leave(err); + } + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::CloseSubSession +// ----------------------------------------------------------------------------- +// +void CSipCSSession::CloseSubSession (TInt aSubSessionHandle) + { + iSubSessionIndex->Remove(aSubSessionHandle); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ClientReadyToReceiveL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::ClientReadyToReceiveL (const RMessage2& aMessage) + { + iReceiver->ClientReadyToReceiveL(aMessage); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::ReceiveSipMessageL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::ReceiveSipMessageL (const RMessage2& aMessage) + { + iReceiver->WriteSipMessageToClientL(aMessage); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::CancelClientReceiveL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::CancelClientReceiveL () + { + iReceiver->CancelClientReceiveL(); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::CallSubSessionL +// ----------------------------------------------------------------------------- +// +void CSipCSSession::CallSubSessionL (TInt aSubSessionHandle, + const RMessage2& aMessage) + { + CSipCSSubSession* subSession = + static_cast( + iSubSessionIndex->AtL(aSubSessionHandle)); + TSIPIds ids = ITC().ReadSipIdsL(aMessage); + subSession->ServiceL(ids,aMessage.Function(),aMessage); + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::Exists +// ----------------------------------------------------------------------------- +// +TBool CSipCSSession::Exists (TUint32 aIapId) + { + for (TInt i=0; i < iSubSessions->Count(); i++) + { + CSipCSSubSession* subSession = + static_cast((*iSubSessions)[i]); + if (subSession->IapId() == aIapId) + { + return ETrue; + } + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSipCSSession::FindSIPSecUser +// ----------------------------------------------------------------------------- +// +const MSIPSecUser* CSipCSSession::FindSIPSecUser( + TRefreshId aRefreshId, + TTransactionId aTransactionId) + { + if (aRefreshId != KEmptyRefreshId) + { + return ServerCore().RefreshMgr().SIPSecUser(aRefreshId); + } + if (aTransactionId == KEmptyTransactionId) + { + return NULL; + } + + const MSIPSecUser* user = + ServerCore().RegistrationMgr().SIPSecUserForTransaction(aTransactionId); + if (!user) + { + user = + ServerCore().DialogMgr().SIPSecUserForTransaction(aTransactionId); + } + if (!user) + { + // If the transaction ID is not empty, + // the user of SIP API implements MSIPHttpDigestChallengeObserver2 + user = iReceiver; + } + return user; + }