// Copyright (c) 2003-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          : CSipConnectionMgr.cpp

// Part of       : ConnectionMgr

// Version       : SIP/4.0 

//

#include "CSipConnectionMgr.h"

#include "CSipConnection.h"

#include "MTransactionFinder.h"

#include "Lwtimer.h"

#include "SipLogs.h"

#include "CleanupResetAndDestroy.h"

#include "sipsigcomphandler.h"

#include "sipsigcompnotintegrated.h"

#include "CNetworkManager.h"

#include "TSIPTransportParams.h"

#include "sipsigcomphandlerinitparams.h"

#include "NetworkInfo.h"

#include "CNATTraversalNotIntegrated.h"

#include "SipAssert.h"

#include "cellulardatausagemonitor.h"

#include <sipnattraversalcontroller.h>

#include <sipnattraversalcontrollerinitparams.h>

#include <sipsystemstatemonitor.h>

const TUint KSIPMessageSlots = 32;

const TInt CSipConnection::iConnectionOffset =

	_FOFF(CSipConnection, iConnectionLink);

// -----------------------------------------------------------------------------

// CSipConnectionMgr::NewL

// -----------------------------------------------------------------------------

//

CSipConnectionMgr* CSipConnectionMgr::NewL( MTransactionFinder& aFinder, 

		MServerTaFactory& aTaFactory, MTimerManager& aTimer, TUint aTOne, 

		MConnectionStateObserver& aNetworkObserver )

	{

	CSipConnectionMgr* self = NewLC( aFinder, aTaFactory, aTimer, 

								   	 aTOne, aNetworkObserver );

	CleanupStack::Pop( self );

	return self;

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::NewLC

// -----------------------------------------------------------------------------

//

CSipConnectionMgr* CSipConnectionMgr::NewLC( MTransactionFinder& aFinder, 

		MServerTaFactory& aTaFactory, MTimerManager& aTimer, TUint aTOne, 

		MConnectionStateObserver& aNetworkObserver )

	{

	CSipConnectionMgr* self =

		new (ELeave) CSipConnectionMgr( aFinder, aTaFactory,

									    aTimer, aTOne, aNetworkObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CSipConnectionMgr

// -----------------------------------------------------------------------------

//

CSipConnectionMgr::CSipConnectionMgr( MTransactionFinder& aFinder, 

		MServerTaFactory& aTaFactory, MTimerManager& aTimer, TUint aTOne, 

		MConnectionStateObserver& aNetworkObserver ) : 

		iFinder( &aFinder ), iTaFactory( &aTaFactory ),

		iTimer( &aTimer ), iTOne( aTOne ), 

		iConnectionList( CSipConnection::iConnectionOffset ), 

		iConnectionListIter( iConnectionList )

	{

	iTUNetStatusObserver = &aNetworkObserver;

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::ConstructL

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::ConstructL()

	{

	User::LeaveIfError( iSocketServ.Connect( KSIPMessageSlots ) );	

	iNetworkManager = CNetworkManager::NewL();	

	iNetworkInfo = CNetworkInfo::NewL(*iNetworkManager);	

	LoadSigCompL();

	LoadNATTraversalL();

	LoadSystemStateMonitorL();

	iCellularDataUsageMonitor = CSipCellularDataUsageMonitor::NewL(*this);

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::~CSipConnectionMgr

// -----------------------------------------------------------------------------

//

CSipConnectionMgr::~CSipConnectionMgr()

	{

	RemoveAllConnections();

	iSocketServ.Close();

	delete iSigCompController;

	delete iNATTraversal;

	delete iSystemStateMonitor;

	delete	iCellularDataUsageMonitor;

	//Must delete iNetworkInfo before iNetworkManager

	delete iNetworkInfo;

	delete iNetworkManager;	

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::OpenL

// -----------------------------------------------------------------------------

//

CSIPConnection::TState CSipConnectionMgr::OpenL(

    const TSIPTransportParams& aParams)

    {

    TUint32 iapId = aParams.IapId();

   	__ASSERT_ALWAYS( iapId > 0, User::Leave(KErrBadName) );

	CSipConnection* connection = 0;

	if ( ConnectionExists( iapId ) )

		{

		connection = Connection( iapId );

		}

	else

		{

		connection = CreateNewConnectionL( aParams );

		}

	connection->IncreaseUserCount();

	return connection->State();

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::IsOpen

// -----------------------------------------------------------------------------

//

TBool CSipConnectionMgr::IsOpen( const TSIPTransportParams& aParams )

    {

    return ConnectionExists( aParams.IapId() );

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::Close

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::Close( const TSIPTransportParams& aParams )

    {

    TUint32 iapId = aParams.IapId();

    if ( ConnectionExists( iapId ) )

		{

		if ( Connection( iapId )->DecreaseUserCount( aParams ) == 0 )

			{

			RemoveConnection( iapId );

			}

		}

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::SetOptL

// -----------------------------------------------------------------------------

//	

void CSipConnectionMgr::SetOptL(

    const TSIPTransportParams& aParams,

    TUint aOptionName,

	TUint aOptionLevel,

	const TDesC8& aOption )

    {

    __ASSERT_ALWAYS( aParams.OwnerId() > 0, User::Leave( KErrArgument ) );

    TUint32 iapId = aParams.IapId();

    if ( ConnectionExists( iapId ) )

		{

		Connection( iapId )->SetOptL( 

		    aParams, aOptionName, aOptionLevel, aOption );

		}

	else

        {

        User::Leave( KErrNotFound );

        }

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::SetOptL

// -----------------------------------------------------------------------------

//	         	                         

void CSipConnectionMgr::SetOptL(

    const TSIPTransportParams& aParams,

    TUint aOptionName,

	TUint aOptionLevel,

	TInt aOption )

    {

    __ASSERT_ALWAYS( aParams.OwnerId() > 0, User::Leave( KErrArgument ) );

    TUint32 iapId = aParams.IapId();

    if ( ConnectionExists( iapId ) )

		{

		Connection( iapId )->SetOptL( 

		    aParams, aOptionName, aOptionLevel, aOption );

		}

	else

        {

        User::Leave( KErrNotFound );

        }

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::SendL

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::SendL(

    const TSIPTransportParams& aParams,

	CSIPRequest& aRequest,

	TBool aForceUDP,

	const CUri8* aOutboundProxy,

	const TInetAddr& aRemoteAddr, 

	TRequestStatus& aStatus )

    {

    TUint32 iapId = aParams.IapId();

    if ( ConnectionExists( iapId ) )

		{

		Connection( iapId )->SendL( aParams, 

		                            aRequest,

		                            aForceUDP, 

		                            aOutboundProxy, 

		                            aRemoteAddr, 

		                            aStatus );

		}

	else

        {

        User::Leave( KErrNotFound );

        }

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::SendL

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::SendL(

    const TSIPTransportParams& aParams,

    CSIPResponse& aResponse,

    TTransactionId aId,

    TRequestStatus& aStatus )

    {

    TUint32 iapId = aParams.IapId();

    if ( ConnectionExists( iapId ) )

		{

		Connection( iapId )->SendL( aParams, aResponse, aId, aStatus );

		}

    else

        {

        User::Leave( KErrNotFound );

        }

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CancelSend

// -----------------------------------------------------------------------------

//

TInt CSipConnectionMgr::CancelSend( TRequestStatus &aStatus )

    {

    CSipConnection* connection = 0;

    TInt ret( KErrNotFound );

	iConnectionListIter.SetToFirst();	

	while ( ( connection = iConnectionListIter++ ) != 0 && 

	        ( ret == KErrNotFound ) )

	    {

	    ret = connection->CancelSend( aStatus );

	    }

	return ret;

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CancelResponseSend

// -----------------------------------------------------------------------------

//

TInt CSipConnectionMgr::CancelResponseSend( 

    TTransactionId aId, 

    TBool aCancelAlso2xxResponses )

    {

    CSipConnection* connection = 0;

    TInt ret( KErrNotFound );

	iConnectionListIter.SetToFirst();

	while ( ( connection = iConnectionListIter++ ) != 0 &&

	        ( ret == KErrNotFound ) )

	    {

	    ret = connection->CancelResponseSend( aId, aCancelAlso2xxResponses );

	    }

	return ret;

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::TcpDisconnect

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::TcpDisconnect(

    const TSIPTransportParams& aParams,

	const TInetAddr& aRemoteAddress )

    {

    TUint32 iapId = aParams.IapId();

    if ( ConnectionExists( iapId ) )

		{

		Connection( iapId )->TcpDisconnect( aParams, aRemoteAddress );

		}

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::FreeResources

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::FreeResources( 

    MSIPNATBindingObserver& aSIPNATBindingObserver )

    {

    CSipConnection* connection = 0;

	iConnectionListIter.SetToFirst();

	while ( (connection = iConnectionListIter++) != 0 )

		{

		connection->FreeResources( aSIPNATBindingObserver );

		}

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::GetByURIL

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::GetByURIL( 

    const CURIContainer& aURI,

    RPointerArray<MSIPResolvingResult>& aResult,

	const TSIPTransportParams& aParams,

	MSIPServerResolverObserver* aObserver )

	{

	TUint32 iapId = aParams.IapId();

	if ( ConnectionExists( iapId ) )

		{

		Connection( iapId )->GetByURIL( aParams, aURI, aResult, aObserver );

		}

	else

		{

	    User::Leave( KErrNotReady );

		}

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CancelGetByUri

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::CancelGetByUri( 

    MSIPServerResolverObserver* aObserver )

	{

	CSipConnection* connection = 0;

	iConnectionListIter.SetToFirst();

	while ( (connection = iConnectionListIter++) != 0 )

		{

		connection->CancelGetByUri( aObserver );

		}

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::IsSupported

// -----------------------------------------------------------------------------

//

TBool CSipConnectionMgr::IsSupported() const

	{

	return iSigCompController->IsSupported();

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CreateCompartmentL

// -----------------------------------------------------------------------------

//

TUint32 CSipConnectionMgr::CreateCompartmentL( 

    TUint32 aIapId )

    {

    __ASSERT_ALWAYS( iSigCompController->IsSupported(), 

                     User::Leave( KErrNotSupported ) );

	return iSigCompController->CreateCompartmentL( aIapId );

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::RemoveCompartment

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::RemoveCompartment( TUint32 aCompartmentId )

    {

   	if ( iSigCompController->IsSupported() )

		{

		iSigCompController->RemoveCompartment( aCompartmentId );

		}

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CompartmentCount

// -----------------------------------------------------------------------------

//

TInt CSipConnectionMgr::CompartmentCount()

	{

	return iSigCompController->CompartmentCount();

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::SendFailedL

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::SendFailedL( TUint32 aCompartmentId ) 

	{

	iSigCompController->SendFailedL( aCompartmentId );

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::Match

// -----------------------------------------------------------------------------

//

TBool CSipConnectionMgr::Match( const TDesC8& aAddress )

	{

	CSipConnection* connection = 0;

	iConnectionListIter.SetToFirst();

	while ( ( connection = iConnectionListIter++ ) != 0 )

		{

		if ( connection->Match( aAddress ) )

			{

			return ETrue;

			}

		}

	return EFalse;

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::IsSystemStarted

// -----------------------------------------------------------------------------

//

TBool CSipConnectionMgr::IsSystemStarted() const

    {            

    return ( iSystemState == CSipSystemStateMonitor::ESystemReady );

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::Destroy

// -----------------------------------------------------------------------------

//	

void CSipConnectionMgr::Destroy( TUint32 aIapId )

	{

	RemoveConnection( aIapId );

	}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::IsCellularDataUsageAllowed

// -----------------------------------------------------------------------------

//	

TBool CSipConnectionMgr:: IsCellularDataUsageAllowed() const

{

TBool val =  (MSipCellularDataUsageObserver::EDataUsageAllowed == iCellularDataUsageMonitor->CellularUsageStatus());

__SIP_INT_LOG1( "CSipConnectionMgr::IsCellularDataUsageAllowed, return value", val )  

	return val;

}

// -----------------------------------------------------------------------------

// CSipConnectionMgr::ReserveTransportL

// -----------------------------------------------------------------------------

//		

void CSipConnectionMgr::ReserveTransportL( 

    TSIPTransportParams& aTransportParams,

    TUint aLocalSendPort,

	TUint aLocalReceivePort,

	const TInetAddr& aRemoteAddr,

	TUint aRemoteSendPort )

    {

    TUint32 iapId = aTransportParams.IapId();

   	if ( ConnectionExists( iapId ) )

		{

		// Old transport params are possibly used (if tp id is not default)

		// for mapping two related transports together. This is for the IPSec

		// need where two records are sharing the same listening port

		TSIPTransportParams oldTransportParams( aTransportParams );

		aTransportParams.SetTransportId( CreateTransportId() );

		CSipConnection* con = Connection( iapId );

		TRAPD( err, con->ReserveTransportL( oldTransportParams,

		                                    aTransportParams,

                                            aLocalSendPort,

                                            aLocalReceivePort,

                                            aRemoteAddr,

                                            aRemoteSendPort ) );

		if ( err )

		    {

		    TInt ignored( 0 );

		    con->RemoveReservedTransport( aTransportParams.TransportId(), 

		                                  0, 

		                                  ignored );

		    User::Leave( err );

		    }

		}

	else

        {

        User::Leave( KErrNotFound );

        }

    }

// -----------------------------------------------------------------------------

// CSipConnectionMgr::CreateTLSTransportL

// -----------------------------------------------------------------------------

//

void CSipConnectionMgr::CreateTLSTransportL( 

    TSIPTransportParams& aTransportParams )

    {

    TUint32 iapId = aTransportParams.IapId();

   	if ( ConnectionExists( iapId ) )

		{

		aTransportParams.SetTransportId( CreateTransportId() );