diff -r 000000000000 -r 1bce908db942 multimediacommsengine/tsrc/testdriver/siptester/src/CTcSIPContext.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/tsrc/testdriver/siptester/src/CTcSIPContext.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,370 @@ +/* +* Copyright (c) 2004 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: Implementation. +* +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "TesterConstants.h" +#include "tcuid.h" +#include "TcLog.h" +#include "CTcFileHandler.h" +#include "ErrorHandling.h" + +#include "CTcSIPProfileContainer.h" +#include "CTcSIPConnectionContainer.h" +#include "CTcSIPHttpDigestContainer.h" +#include "CTcSIPClientDiscoveryContainer.h" +#include "CTcSIPContext.h" +#include "SIPConstants.h" +#include "TTcSIPCommandBase.h" +#include "TTcSIPReceived.h" +#include "CTTcSIPFactory.h" +#include "CTcSIPIMSAuthenticator.h" +#include + +#include "CommandIndex.h" + +CTcSIPContext* CTcSIPContext::NewLC( CTcCTRLCodec& aCodec, + TInt aIAPId, + TBool aIsMandatory ) + { + CTcSIPContext* self = new( ELeave ) CTcSIPContext( aCodec ); + + CleanupStack::PushL( self ); + self->ConstructL( aIAPId, aIsMandatory ); + + return self; + } + +CTcSIPContext::~CTcSIPContext() + { + TcLog::Write( _L8("CTcSIPContext::~CTcSIPContext() start\n") ); + + iSipClientSimulator.Close(); + + delete iFileHandler; + + delete iIMSAuthenticator; + + iFreezer->Remove( iTimerEntry ); + delete iFreezer; + + // Must be deleted before deleting transactions (in registry) + delete iSipConnection; + + // We have to delete SIP Profiles before deleting + // ManagedProfileRegistry instance. + iRegistry.DestroyAll(); + + delete iSipClientDiscovery; + delete iSipHttpDigest; + delete iSipProfile; + SIPHeaderLookup::Close(); + delete iSip; + delete iIapManager; + delete iCenRep; + TcLog::Write( _L8("CTcSIPContext::~CTcSIPContext() end\n") ); + } + +CTcSIPContext::CTcSIPContext( CTcCTRLCodec& aCodec ) + : CTcContextBase( aCodec ), iIsMandatory( EFalse ), iSipClientDiscovery( 0 ) + { + } + +void CTcSIPContext::ConstructL( TInt aIAPId, TBool aIsMandatory ) + { + iIAPId = aIAPId; + iIsMandatory = aIsMandatory; + + TcLog::Write( _L8("CTcSIPContext::ConstructL() start\n") ); + iIapManager = CTcIAPManager::NewL(); + + iFileHandler = CTcFileHandler::NewL(); + + iFreezer = CDeltaTimer::NewL( CActive::EPriorityStandard ); + + if ( !iIsMandatory ) + { + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP client\n") ); + iSip = CSIP::NewL( TUid::Uid( TCUID ), *this ); + iSipConnection = CTcSIPConnectionContainer::NewL( *this, IAPNameL( aIAPId ) ); + SIPHeaderLookup::OpenL(); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Profiles client\n") ); + iSipProfile = CTcSIPProfileContainer::NewL( *this, *iSip ); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Http Digest\n") ); + iSipHttpDigest = CTcSIPHttpDigestContainer::NewL( *this, *iSip ); + } + + User::LeaveIfError( iSipClientSimulator.Connect() ); + + iCenRep = CRepository::NewL( KCRUidSIPClientResolverConfig ); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() end\n") ); + } + +// -- CTcContextBase functions ------------------------------------------------ + +TTcCommandBase* CTcSIPContext::CreateCommandL( TTcIdentifier& aId, + MTcTestContext& aContext ) + { + // Use base class to actually create commands. Just provide the command + // array and its size. + return CTcContextBase::CreateCommandL( KTcSIPCommands, + sizeof( KTcSIPCommands ), + aId, aContext ); + } + +// -- MSIPObserver functions -------------------------------------------------- + +// Note that adding an object by-reference to the registry does NOT transfer +// ownership. Adding by-pointer does transfer ownership, however. +// Most/all SIP objects should be in the registry at this stage anyway, +// just make sure that's the case. + +void CTcSIPContext::IncomingRequest( TUint32 aIapId, + CSIPServerTransaction* aTransaction ) + { + TRAPD( err, { + iRegistry.AddObjectL( aTransaction ); + TTcSIPReceived received; + received.Set( aIapId ); + received.Set( aTransaction ); + iSipConnection->QueueReceivedL( received ); + } ) + __ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) ); + } + +void CTcSIPContext::TimedOut( CSIPServerTransaction& aSIPServerTransaction ) + { + TRAPD( err, { + iRegistry.AddObjectL( aSIPServerTransaction ); + TTcSIPReceived received; + received.Set( &aSIPServerTransaction ); + received.SetError( KErrTimedOut ); + iSipConnection->QueueReceivedL( received ); + } ) + __ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) ); + } + +// +// -- Internal utility functions ---------------------------------------------- +// +TBool CTcSIPContext::GetMandatoryValue( void ) const + { + return iIsMandatory; + } + +void CTcSIPContext::CreateSipStack( void ) + { + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP client\n") ); + iSip = CSIP::NewL( TUid::Uid( TCUID ), *this ); + iSipConnection = CTcSIPConnectionContainer::NewL( *this, IAPNameL( iIAPId ) ); + SIPHeaderLookup::OpenL(); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Profiles client\n") ); + iSipProfile = CTcSIPProfileContainer::NewL( *this, *iSip ); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Http Digest\n") ); + iSipHttpDigest = CTcSIPHttpDigestContainer::NewL( *this, *iSip ); + } + +CTcSIPConnectionContainer* CTcSIPContext::CreateSipStack( const TDesC8& aName ) + { + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP client\n") ); + iSip = CSIP::NewL( TUid::Uid( TCUID ), *this ); + iSipConnection = CTcSIPConnectionContainer::NewL( *this, aName); + SIPHeaderLookup::OpenL(); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Profiles client\n") ); + iSipProfile = CTcSIPProfileContainer::NewL( *this, *iSip ); + + TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Http Digest\n") ); + iSipHttpDigest = CTcSIPHttpDigestContainer::NewL( *this, *iSip ); + + return iSipConnection; + } + +CTcSIPHttpDigestContainer& CTcSIPContext::DigestContainerL() + { + __ASSERT_ALWAYS( iSipHttpDigest, User::Leave( KErrNotFound ) ); + return *iSipHttpDigest; + } + +void CTcSIPContext::RemoveDigestContainer() + { + delete iSipHttpDigest; + iSipHttpDigest = NULL; + } + +void CTcSIPContext::CreateClientDiscoveryL( TUid aUid ) + { + __ASSERT_ALWAYS( !iSipClientDiscovery, User::Leave( KErrAlreadyExists ) ); + #ifdef RD_SIP_TESTER + iSipClientDiscovery = CTcSIPClientDiscoveryContainer::NewL( *this, aUid ); + #else + aUid.iUid; // Avoid compiler warning + #endif // RD_SIP_TESTER + } + +void CTcSIPContext::RemoveClientDiscovery() + { + #ifdef RD_SIP_TESTER + delete iSipClientDiscovery; + iSipClientDiscovery = 0; + #endif // RD_SIP_TESTER + } + +CTcSIPClientDiscoveryContainer& CTcSIPContext::ClientDiscoveryL() + { + __ASSERT_ALWAYS( iSipClientDiscovery, User::Leave( KErrNotFound ) ); + return *iSipClientDiscovery; + } + +void CTcSIPContext::IssueFreezeL( TInt aFreezeTimeSeconds ) + { + if ( iFreezer->IsActive() ) + { + User::Leave( KErrInUse ); + } + + iFreezeTimeSeconds = aFreezeTimeSeconds; + TCallBack callback( Freeze, &iFreezeTimeSeconds ); + iTimerEntry.Set( callback ); + iFreezer->Queue( KFreezeAfterTimer * KSecondAsMicros, iTimerEntry ); + } + +TInt CTcSIPContext::Freeze( TAny* aAny ) + { + TInt freezeTime = *static_cast< TInt* >( aAny ); + User::After( freezeTime * KSecondAsMicros ); + return KErrNone; + } + +CTcSIPIMSAuthenticationParams& CTcSIPContext::AuthenticateL( const TDesC8& aNonce ) + { + if ( !iIMSAuthenticator ) + { + iIMSAuthenticator = CTcSIPIMSAuthenticator::NewL(); + } + return iIMSAuthenticator->AuthenticateL( aNonce ); + } + +const TDesC8& CTcSIPContext::SIPErrorToText( TInt aError ) + { + switch( aError ) + { + case KErrSIPMalformedMessage: + { + return KSIPMalformedMessageErrMsg; + } + case KErrSIPInvalidRegistrarResponse: + { + return KSIPRegistrarRespondedWithDifferentAORErrMsg; + } + case KErrSIPRequestPending: + { + return KSIPRequestPendingErrMsg; + } + case KErrSIPInvalidTransactionState: + { + return KSIPInvalidTransactionStateErrMsg; + } + case KErrSIPInvalidDialogState: + { + return KSIPInvalidDialogStateErrMsg; + } + case KErrSIPInvalidDialogResponse: + { + return KSIPInvalidResponseInDialogsErrMsg; + } + case KErrSIPInvalidDialogRequest: + { + return KSIPInvalidRequestInDialogsErrMsg; + } + case KErrSIPTransportFailure: + { + return KSIPTransportFailureErrMsg; + } + case KErrSIPNoAckReceived: + { + return KSIPNoAckReceivedErrMsg; + } + case KErrSIPInvalidRegistrationState: + { + return KSIPInvalidRegistrationStateErrMsg; + } + case KErrSIPInvalidContact: + { + return KSIPInvalidContactErrMsg; + } + case KErrSIPResourceNotAvailable: + { + return KSIPResourceNotAvailableErrMsg; + } + case KErrSIPResolvingFailure: + { + return KSIPResolvingFailureErrMsg; + } + case KErrSIPForbidden: + { + return KSIPForbiddenErrMsg; + } + case KErrSIPMaxCompartmentsInUse: + { + return KSIPMaxCompartmentsInUseErrMsg; + } + case KErrSIPTerminatedWithResponse: + { + return KSIPTerminatedWithResponseErrMsg; + } + case KErrSIPOutboundProxyNotResponding: + { + return KSIPOutboundProxyNotRespondingErrMsg; + } + case KSIPErrInviteCanceled: + { + return KSIPInviteCanceledErrMsg; + } + default: + { + return KSIPUnrecognizedErrMsg; + } + } + } + +RSipClientSimulator& CTcSIPContext::SipClientSimulator() + { + return iSipClientSimulator; + } + +CRepository& CTcSIPContext::Repository() + { + return *iCenRep; + } +