// 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        : COwnerSettings.cpp
// Part of     : ConnectionMgr
// See class definition below.
// Version     : SIP/4.0
//



#include <in_sock.h>

#include "COwnerSettings.h"
#include "CSocketOpt.h"
#include "CommonConsts.h"
   
const TInt KSocketOptsGranularity = 2;
const TInt KPortsGranularity = 2;

// -----------------------------------------------------------------------------
// COwnerSettings::NewLC
// -----------------------------------------------------------------------------
//
COwnerSettings* COwnerSettings::NewLC( const TSIPTransportParams& aParams )
    {
    COwnerSettings* self = new ( ELeave ) COwnerSettings( aParams );
    CleanupStack::PushL( self );
    return self;
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::~COwnerSettings
// -----------------------------------------------------------------------------
//
COwnerSettings::~COwnerSettings()
    {
    delete iRemoteAddr;
    iSocketOpts.ResetAndDestroy();
    iOriginalOpts.ResetAndDestroy();
    iPorts.Close();
    }

// -----------------------------------------------------------------------------
// COwnerSettings::COwnerSettings
// -----------------------------------------------------------------------------
//    
COwnerSettings::COwnerSettings( const TSIPTransportParams& aParams ) :
    iSocketOpts( KSocketOptsGranularity ),
    iPorts( KPortsGranularity ),
	iParams( aParams ),
	iUseTLS( EFalse )
    {
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::AddOptL
// -----------------------------------------------------------------------------
//
void COwnerSettings::AddOptL(
    TUint aOptionName,
	TUint aOptionLevel,
	TInt aOption )
    {
    CSocketOpt* sockopt = 
                    CSocketOpt::NewLC( aOptionName, aOptionLevel, aOption );
    AddOptL( sockopt );
    CleanupStack::Pop( sockopt );
    }   
    
// -----------------------------------------------------------------------------
// COwnerSettings::AddOptL
// -----------------------------------------------------------------------------
//
void COwnerSettings::AddOptL(
    TUint aOptionName,
	TUint aOptionLevel,
	const TDesC8& aOption )
    {
    CSocketOpt* sockopt = 
                    CSocketOpt::NewLC( aOptionName, aOptionLevel, aOption );
    AddOptL( sockopt );
    CleanupStack::Pop( sockopt );
    }   

// -----------------------------------------------------------------------------
// COwnerSettings::TransportParams
// -----------------------------------------------------------------------------
//      
const TSIPTransportParams& COwnerSettings::TransportParams() const
    {
    return iParams;
    }

// -----------------------------------------------------------------------------
// COwnerSettings::SetOpts
// -----------------------------------------------------------------------------
//     
void COwnerSettings::SetOpts( RSocket& aSocket )
    {
    // Clear original opts, those will be re-created while setting new options
    iOriginalOpts.ResetAndDestroy();
    
    TRAP_IGNORE( SetOptsL( aSocket ) )
    }

// -----------------------------------------------------------------------------
// COwnerSettings::ClearOpts
// -----------------------------------------------------------------------------
//     
void COwnerSettings::ClearOpts( RSocket& aSocket )
    {
    TRAP_IGNORE( ClearOptsL( aSocket ) )
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::RememberPortsL
// -----------------------------------------------------------------------------
//    
void COwnerSettings::SaveTransportInfoL( 
    TUint aLocalSendPort,
    TUint aLocalReceivePort,
    const TInetAddr& aRemoteAddr,
    TUint aRemoteSendPort )
    {
    __ASSERT_ALWAYS( !iLocalSendPort && 
                     !iLocalReceivePort && 
                     !iRemoteAddr &&
                     !iRemoteSendPort, 
                     User::Leave( KErrAlreadyExists ) );
     
    iRemoteAddr = new ( ELeave ) TInetAddr( aRemoteAddr );                
    iLocalSendPort = aLocalSendPort;
    iLocalReceivePort = aLocalReceivePort;
    iRemoteSendPort = aRemoteSendPort;
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::AddReservedPortL
// -----------------------------------------------------------------------------
//       
void COwnerSettings::AddReservedPortL( TUint aPort )
    {
    // Don't allow duplicates in the array, however in such situation no need
    // to leave
    TInt err = iPorts.InsertInOrder( aPort );
    if ( err && err != KErrAlreadyExists )
        {
        User::Leave( err );
        }
    }

// -----------------------------------------------------------------------------
// COwnerSettings::IsUnreservedPort
// -----------------------------------------------------------------------------
//    
TBool COwnerSettings::IsUnreservedPort( TUint aPort ) const
    {
    TInt count = iPorts.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        if ( iPorts[ i ] == aPort )
            {
            return EFalse;
            }
        }
    return ETrue;
    }

// -----------------------------------------------------------------------------
// COwnerSettings::IsOpts
// -----------------------------------------------------------------------------
//      
TBool COwnerSettings::IsOpts() const
    {
    return ( iSocketOpts.Count() > 0 );
    }
 
// -----------------------------------------------------------------------------
// COwnerSettings::LocalSendPort
// -----------------------------------------------------------------------------
//         
TUint COwnerSettings::LocalSendPort() const
    {
    return iLocalSendPort;
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::LocalReceivePort
// -----------------------------------------------------------------------------
//         
TUint COwnerSettings::LocalReceivePort() const
    {
    return iLocalReceivePort;
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::RemoteAddr
// -----------------------------------------------------------------------------
//         
const TInetAddr* COwnerSettings::RemoteAddr() const
    {
    return iRemoteAddr;
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::IsMatchingWithSavedInfo
// -----------------------------------------------------------------------------
//         
TBool COwnerSettings::IsMatchingWithSavedInfo( 
    const TSIPTransportParams& aParams, 
    const TInetAddr& aRemoteAddr,
    TUint aProtocol,
    TUint aLocalPort ) const
    {
    TUint32 transportId( aParams.TransportId() );
    TBool isReservedTransport( transportId > 0 );
    
    TBool addressMatch( EFalse );
    
    if ( aProtocol == KProtocolInetUdp && isReservedTransport )
        {
        // In case of protected UDP, check only remote send and local receive
        // ports
        addressMatch = ( IsMatchingWithRemoteSendAddr( aRemoteAddr, ETrue ) &&
                         iLocalReceivePort == aLocalPort );
        }
    else
        {
        // Otherwise check both, remote and local, send and receive ports
        addressMatch = ( IsMatchingWithRemoteSendAddr( aRemoteAddr, EFalse ) &&
                         ( iLocalReceivePort == aLocalPort ||
                           iLocalSendPort == aLocalPort ) );
        }
    return ( addressMatch &&
             ( !isReservedTransport || iParams.TransportId() == transportId ) );
    }

// -----------------------------------------------------------------------------
// COwnerSettings::IsMatchingWithRemoteSendAddr
// -----------------------------------------------------------------------------
//    
TBool COwnerSettings::IsMatchingWithRemoteSendAddr( 
    const TInetAddr& aRemoteSendAddr,
    TBool aCheckOnlySendPort ) const
    {
    if ( !iRemoteAddr )
        {
        return EFalse;
        }
    
    TBool portMatch = ( iRemoteSendPort == aRemoteSendAddr.Port() );
    if ( !aCheckOnlySendPort && !portMatch )
        {
        portMatch = ( iRemoteAddr->CmpPort( aRemoteSendAddr ) );
        }

    return ( iRemoteAddr->Match( aRemoteSendAddr ) && portMatch );
    }

// -----------------------------------------------------------------------------
// COwnerSettings::SetUseTLS
// -----------------------------------------------------------------------------
//   
void COwnerSettings::SetUseTLS( TBool aUseTLS )
    {
    iUseTLS = aUseTLS;
    }

// -----------------------------------------------------------------------------
// COwnerSettings::UseTLS
// -----------------------------------------------------------------------------
//     
TBool COwnerSettings::UseTLS() const
    {
    return iUseTLS;
    }

// -----------------------------------------------------------------------------
// COwnerSettings::SaveTLSRemoteL
// -----------------------------------------------------------------------------
// 
void COwnerSettings::SaveTLSRemoteL( const TInetAddr& aRemoteAddr )   
    {
    __ASSERT_ALWAYS( iUseTLS, User::Leave( KErrNotReady ) );
    
    TInetAddr* remoteAddr = new ( ELeave ) TInetAddr( aRemoteAddr );  
    delete iRemoteAddr;
    iRemoteAddr = remoteAddr;
    
    iRemoteAddr->SetPort( KDefaultSipsPort );
    }
    
// -----------------------------------------------------------------------------
// COwnerSettings::AddOptL
// -----------------------------------------------------------------------------
//
void COwnerSettings::AddOptL( CSocketOpt* aSocketOpt )
    {
    __ASSERT_ALWAYS( aSocketOpt, User::Leave( KErrArgument ) );
    // Don't allow multiple socket opts with same option name
    for ( TInt i = 0; i < iSocketOpts.Count(); i++ )
        {
        if ( iSocketOpts[ i ]->OptionName() == aSocketOpt->OptionName() )
            {
            delete iSocketOpts[ i ];
            iSocketOpts.Remove( i );
            iSocketOpts.InsertL( aSocketOpt, i );
            return;
            }
        }
    iSocketOpts.AppendL( aSocketOpt );
    }

// -----------------------------------------------------------------------------
// COwnerSettings::SetOptsL
// -----------------------------------------------------------------------------
//
void COwnerSettings::SetOptsL( RSocket& aSocket )
    {
    TInt count = iSocketOpts.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        // Store previous opt as it will be used when ClearOpts is called
        CSocketOpt* previousOpt = iSocketOpts[ i ]->SetOptL( aSocket );
        if ( previousOpt )
            {
            CleanupStack::PushL( previousOpt );
            iOriginalOpts.AppendL( previousOpt );
            CleanupStack::Pop( previousOpt );
            }
        }
    }

// -----------------------------------------------------------------------------
// COwnerSettings::ClearOptsL
// -----------------------------------------------------------------------------
//     
void COwnerSettings::ClearOptsL( RSocket& aSocket )
    {
    TInt count = iOriginalOpts.Count();
    for ( TInt i = 0; i < count; i++ )
        {
        CSocketOpt* previousOpt = iOriginalOpts[ i ]->SetOptL( aSocket );
        // Not interested about previous value
        delete previousOpt;
        }
    }
       
// end of file