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

// Part of     : ConnectionMgr

// See class definition below.

// Version     : SIP/4.0

//

#include "COwnerSettingsList.h"

#include "COwnerSettings.h"

#include "CommonConsts.h"

#include "siperr.h"

const TInt KSettingsGranularity = 2;

const TUint KFirstUnreservedPort = KDefaultSipPort+2;

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

// COwnerSettingsList::NewL

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

//

COwnerSettingsList* COwnerSettingsList::NewL()

    {

    COwnerSettingsList* self = new ( ELeave ) COwnerSettingsList;

    return self;

    }

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

// COwnerSettingsList::~COwnerSettingsList

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

//

COwnerSettingsList::~COwnerSettingsList()

    {

    iSettings.ResetAndDestroy();

    }

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

// COwnerSettingsList::COwnerSettingsList

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

//    

COwnerSettingsList::COwnerSettingsList() :

    iSettings( KSettingsGranularity )

    {

    }

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

// COwnerSettingsList::AddSettingsL

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

//

void COwnerSettingsList::AddSettingsL(     

    const TSIPTransportParams& aParams,

    TUint aOptionName,

	TUint aOptionLevel,

	TInt aOption )

    {

    COwnerSettings& settings = FindOwnerSettingsL( aParams );

    settings.AddOptL( aOptionName, aOptionLevel, aOption );

    }

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

// COwnerSettingsList::AddSettingsL

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

//

void COwnerSettingsList::AddSettingsL(     

    const TSIPTransportParams& aParams,

    TUint aOptionName,

	TUint aOptionLevel,

	const TDesC8& aOption )

    {

    COwnerSettings& settings = FindOwnerSettingsL( aParams );

    settings.AddOptL( aOptionName, aOptionLevel, aOption );

    }

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

// COwnerSettingsList::RemoveSettings

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

//

void COwnerSettingsList::RemoveSettings( const TSIPTransportParams& aParams )

    {

    // Remove all settings of this owner

    TInt count = iSettings.Count();

    for ( TInt i = ( count-1 ); i >= 0; i-- )

        {

        if ( iSettings[ i ]->TransportParams().OwnerId() == aParams.OwnerId() )

            {

            COwnerSettings* settings = iSettings[ i ];

            iSettings.Remove( i );

            delete settings;

            }

        }

    iSettings.Compress();

    }

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

// COwnerSettingsList::RemoveSettings

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

//

TBool COwnerSettingsList::RemoveSettings( TUint32 aTransportId )

    {

    // Remove all settings containing passed transportId

    TBool removed( EFalse );

    TInt count = iSettings.Count();

    for ( TInt i = ( count-1 ); i >= 0; i-- )

        {

        if ( iSettings[ i ]->TransportParams().TransportId() == aTransportId )

            {

            COwnerSettings* settings = iSettings[ i ];

            iSettings.Remove( i );

            delete settings;

            removed = ETrue;

            }

        }

    iSettings.Compress();

    return removed;

    }

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

// COwnerSettingsList::IsRequestedOpts

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

//

TBool COwnerSettingsList::IsRequestedOpts( 

    const TSIPTransportParams& aParams ) const

    {

    TInt count = iSettings.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iSettings[ i ]->TransportParams().OwnerId() == aParams.OwnerId() &&

             iSettings[ i ]->IsOpts() )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// COwnerSettingsList::SetOpts

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

//    

void COwnerSettingsList::SetOpts( 

    const TSIPTransportParams& aParams, 

    RSocket& aSocket )

    {

    // Apply to socket all opts this owner has set

    TInt count = iSettings.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iSettings[ i ]->TransportParams().OwnerId() == aParams.OwnerId() )

            {

            iSettings[ i ]->SetOpts( aSocket );

            }

        }

    }

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

// COwnerSettingsList::ClearOpts

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

//    

void COwnerSettingsList::ClearOpts( 

    const TSIPTransportParams& aParams, 

    RSocket& aSocket )

    {

    // Apply to socket all opts this owner has set

    TInt count = iSettings.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iSettings[ i ]->TransportParams().OwnerId() == aParams.OwnerId() )

            {

            iSettings[ i ]->ClearOpts( aSocket );

            }

        }

    }

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

// COwnerSettingsList::SaveTransportInfoL

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

// 

TBool COwnerSettingsList::SaveTransportInfoL( 

    const TSIPTransportParams& aOldParams, 

    const TSIPTransportParams& aParams, 

    TUint aLocalSendPort,

    TUint aLocalReceivePort,

    const TInetAddr& aRemoteAddr,

    TUint aRemoteSendPort )

    { 

    // If there is already settings matching old tp params and old transport id

    // is not default, it is allowed to have duplicate reservations between

    // those two transports since in this case new IPSec record is just changing

    // local sending port but sharing receiving port.

    TInt index( KErrNotFound );

    if ( IsReservedTransport( aOldParams.TransportId() ) )

        {

        index = FindOwnerSettingsIndex( aOldParams );

        }

    for ( TInt i = 0; i < iSettings.Count(); i++ )

        {

        if ( !iSettings[ i ]->IsUnreservedPort( aLocalSendPort ) ||

           ( i != index && !iSettings[ i ]->IsUnreservedPort( aLocalReceivePort ) ) )

            {

            User::Leave( KErrSIPTransportFailure );

            }

        }

    COwnerSettings& settings = FindOwnerSettingsL( aParams );

    settings.SaveTransportInfoL( aLocalSendPort,

                                 aLocalReceivePort,

                                 aRemoteAddr,

                                 aRemoteSendPort );

    settings.AddReservedPortL( aLocalSendPort );

    settings.AddReservedPortL( aLocalReceivePort );

    return ( index != KErrNotFound );

    }

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

// COwnerSettingsList::SaveTLSTransportInfoL

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

// 

void COwnerSettingsList::SaveTLSTransportInfoL( 

    const TSIPTransportParams& aParams )

    { 

    COwnerSettings& settings = FindOwnerSettingsL( aParams, EFalse );

    settings.SetUseTLS( ETrue );

    }

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

// COwnerSettingsList::ReservePrivatePortL

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

// 

void COwnerSettingsList::ReservePrivatePortL( 

    const TSIPTransportParams& aParams, 

    TUint aPort )

    {  

    // Ignore attempt to reserve default sip port. Also ignore protected

    // transports since those use SaveTransportInfoL for reserving ports

    // (two SAs may share same private ports).  

    if ( aPort == KDefaultSipPort || 

         IsReservedTransport( aParams.TransportId() ) )

        {

        return;

        }

    // First check that port is not already reserved 

    // (it can be reserved for owner)

    TInt index = FindOwnerSettingsIndex( aParams );

    for ( TInt i = 0; i < iSettings.Count(); i++ )

        {

        if ( i != index && !iSettings[ i ]->IsUnreservedPort( aPort ) )

            {

            User::Leave( KErrSIPTransportFailure );

            }

        }

    // Then reserve it

    COwnerSettings& settings = FindOwnerSettingsL( aParams );   

    settings.AddReservedPortL( aPort );

    }

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

// COwnerSettingsList::GetPrivatePort

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

//        

TUint COwnerSettingsList::GetPrivatePortL( const TSIPTransportParams& aParams )

    {

    // Find first unreserved port

    TBool found( EFalse );

    TUint unreservedport = KFirstUnreservedPort;

    TInt count = iSettings.Count();  

    for ( TInt i = 0; i < count && !found; i++ )

        {

        if ( iSettings[ i ]->IsUnreservedPort( unreservedport ) )

            {

            found = ETrue;

            }

        else

            {

            unreservedport++;

            }

        }

    // Then reserve it

    COwnerSettings& settings = FindOwnerSettingsL( aParams );   

    settings.AddReservedPortL( unreservedport );

    return unreservedport;

    }

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

// COwnerSettingsList::HasSavedTransportInfo

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

//       

TBool COwnerSettingsList::HasSavedTransportInfo( 

    TUint32 aTransportId ) const

    {

    return ( FindOwnerSettingsIndex( aTransportId ) != KErrNotFound );

    }

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

// COwnerSettingsList::HasSavedTLSTransportInfo

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

//    

TBool COwnerSettingsList::HasSavedTLSTransportInfo( TUint32 aTransportId ) const

    {

    TInt index( KErrNotFound );

    if ( ( index = FindOwnerSettingsIndex( aTransportId ) ) != KErrNotFound )

        {

        return iSettings[ index ]->UseTLS();

        }

    return EFalse;

    }

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

// COwnerSettingsList::SavedLocalSendPort

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

//      

TUint COwnerSettingsList::SavedLocalSendPort( 

    TUint32 aTransportId ) const

    {

    TInt index( KErrNotFound );

    if ( ( index = FindOwnerSettingsIndex( aTransportId ) ) != KErrNotFound )

        {

        return iSettings[ index ]->LocalSendPort();

        }

    return 0;

    }

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

// COwnerSettingsList::SavedLocalReceivePort

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

//      

TUint COwnerSettingsList::SavedLocalReceivePort( 

    TUint32 aTransportId ) const

    {

    TInt index( KErrNotFound );

    if ( ( index = FindOwnerSettingsIndex( aTransportId ) ) != KErrNotFound )

        {

        return iSettings[ index ]->LocalReceivePort();

        }

    return 0;

    }

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

// COwnerSettingsList::SavedRemoteAddr

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

//      

const TInetAddr* COwnerSettingsList::SavedRemoteAddr( 

    TUint32 aTransportId ) const

    {

    TInt index( KErrNotFound );

    if ( ( index = FindOwnerSettingsIndex( aTransportId ) ) != KErrNotFound )

        {

        return iSettings[ index ]->RemoteAddr();

        }

    return 0;

    }

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

// COwnerSettingsList::IsReceivingAllowed

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

//      

TBool COwnerSettingsList::IsReceivingAllowed( 

    const TSIPTransportParams& aParams, 

    const TInetAddr& aRemoteAddr,

    TUint aProtocol,

    TUint aLocalPort ) const

    {

    TBool reservedTransport = IsReservedTransport( aParams.TransportId() );

    // When TLS is used explicitly, there's no need to do remote address

    // specific checking

    if ( reservedTransport && 

         HasSavedTLSTransportInfo( aParams.TransportId() ) )

        {

        return ETrue;

        }

    // If transport id is not specified, receiving from protected (reserved)

    // ports is not allowed. If id is specified, receiving from unprotected

    // ports is not allowed

    TBool match( EFalse );

    for ( TInt i = 0; i < iSettings.Count() && !match; i++ )

        {

        if ( iSettings[ i ]->IsMatchingWithSavedInfo( aParams, 

                                                      aRemoteAddr, 

                                                      aProtocol,

                                                      aLocalPort ) )

            {

            match = ETrue;

            }

        }

    return ( reservedTransport && match ) || ( !reservedTransport && !match );

    }

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

// COwnerSettingsList::FindTransportId

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

//     

TUint32 COwnerSettingsList::FindTransportId( const TInetAddr& aRemoteAddr ) const

    {

    for ( TInt i = 0; i < iSettings.Count(); i++ )

        {

        COwnerSettings* settings = iSettings[ i ];

        if ( settings->IsMatchingWithRemoteSendAddr( aRemoteAddr, ETrue ) )

            {

            return settings->TransportParams().TransportId();

            }

        }

    return 0;

    }

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

// COwnerSettingsList::SaveTLSRemoteL

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

//

void COwnerSettingsList::SaveTLSRemoteL( 

    const TSIPTransportParams& aParams,

    const TInetAddr& aRemoteAddr )

    {

    TInt index( KErrNotFound );

    if ( ( index = FindOwnerSettingsIndex( 

            aParams.TransportId() ) ) != KErrNotFound )

        {

        iSettings[ index ]->SaveTLSRemoteL( aRemoteAddr );

        }

    }

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

// COwnerSettingsList::FindOwnerSettingsL

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

//        

COwnerSettings& COwnerSettingsList::FindOwnerSettingsL( 

    const TSIPTransportParams& aParams, TBool aAllowExisting )

    {

    // Find existing settings for this owner or create new entry to the

    // settings list.

    TInt index( 0 );

    if ( ( index = FindOwnerSettingsIndex( aParams ) ) != KErrNotFound )

        {

        __ASSERT_ALWAYS( aAllowExisting, User::Leave( KErrAlreadyExists ) );

        return *iSettings[ index ];

        }

    COwnerSettings* settings = COwnerSettings::NewLC( aParams );

    iSettings.AppendL( settings );

    CleanupStack::Pop( settings );

    return *settings;

    }

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

// COwnerSettingsList::FindOwnerSettingsIndex

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

//         

TInt COwnerSettingsList::FindOwnerSettingsIndex( 

    const TSIPTransportParams& aParams ) const

    {

    COwnerSettings* settings = 0;

    for ( TInt i = 0; i < iSettings.Count(); i++ )

        {

        settings = iSettings[ i ];

        if ( settings->TransportParams().OwnerId() == aParams.OwnerId() &&

             settings->TransportParams().TransportId() == aParams.TransportId() )

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// COwnerSettingsList::FindOwnerSettingsIndex

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

//         

TInt COwnerSettingsList::FindOwnerSettingsIndex( 

    TUint32 aTransportId ) const

    {

    if ( !IsReservedTransport( aTransportId ) )

        {

        return KErrNotFound;

        }

    COwnerSettings* settings = 0;

    for ( TInt i = 0; i < iSettings.Count(); i++ )

        {

        settings = iSettings[ i ];

        if ( settings->TransportParams().TransportId() == aTransportId )

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// COwnerSettingsList::IsReservedTransport

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

//     

TBool COwnerSettingsList::IsReservedTransport( TUint32 aTransportId ) const

    {

    return ( aTransportId > 0 );

    }

// end of file