--- /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<CSipCSSubSession*>((*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<CSipCSSubSession*>((*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<TSipHttpDigestObserverType>(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<CSipCSSubSession*>(
+ 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<CSipCSSubSession*>((*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;
+ }