/*
* Copyright (c) 2007 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:    
*
*/




#include <badesca.h>
#include <unsafprotocolscrkeys.h>
#include "cnatfwturnsettings.h"
#include "cnatfwserversettings.h" 
#include <mnatfwserversettings.h>
#include "cnatfwcenrephandler.h"
#include "tnatfwsettingsparser.h"
#include "natfwdefaultsettingsvalues.h"
#include "natsettingslogs.h"

const TUint KDefaultGranularity = 2;

// ======== MEMBER FUNCTIONS ========

CNATFWTurnSettings::CNATFWTurnSettings()
    {

    }


void CNATFWTurnSettings::ConstructL( )
    {
    iServerArray = new ( ELeave )
        CArrayPtrFlat<CNATFWServerSettings>( KDefaultGranularity );
    iLatestConnectedServerAddr = KNullDesC8().AllocL();
    }


CNATFWTurnSettings* CNATFWTurnSettings::NewL()
    {
    CNATFWTurnSettings* self = CNATFWTurnSettings::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


CNATFWTurnSettings* CNATFWTurnSettings::NewLC()
    {
    CNATFWTurnSettings* self = new( ELeave ) CNATFWTurnSettings;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


CNATFWTurnSettings::~CNATFWTurnSettings()
    {
    if ( iServerArray )
        {
        iServerArray->ResetAndDestroy();
        }
    delete iServerArray;
    delete iLatestConnectedServerAddr;
    }


// ---------------------------------------------------------------------------
// CNATFWTurnSettings::SetTurnServersL
// ---------------------------------------------------------------------------
//
void CNATFWTurnSettings::SetTurnServersL(
    CArrayPtr<CNATFWServerSettings>* aServers )
    {
    __ASSERT_ALWAYS( NULL != aServers, User::Leave( KErrArgument ) );
    iServerArray->ResetAndDestroy();
    delete iServerArray;
    iServerArray = NULL;
    iServerArray = aServers;
    }


// ---------------------------------------------------------------------------
// CNATFWTurnSettings::SetLatestConnectedServerAddrL
// ---------------------------------------------------------------------------
//
void CNATFWTurnSettings::SetLatestConnectedServerAddrL
    ( const TDesC8& aServerAddr )
    {
    delete iLatestConnectedServerAddr;
    iLatestConnectedServerAddr = NULL;
    iLatestConnectedServerAddr = aServerAddr.AllocL();
    }


// ---------------------------------------------------------------------------
// CNATFWTurnSettings::SetLatestConnectedServerPort
// ---------------------------------------------------------------------------
//
void CNATFWTurnSettings::SetLatestConnectedServerPort( TInt aServerPort )
    {
    iLatestConnectedServerPort = aServerPort;
    }


// ---------------------------------------------------------------------------
// CNATFWTurnSettings::SetRetransmissionTimeout
// ---------------------------------------------------------------------------
//
void CNATFWTurnSettings::SetRetransmissionTimeout( TUint aRto )
    {
    iRto = aRto;
    }
    

// ---------------------------------------------------------------------------
// CNATFWTurnSettings::ReadSettingsL
// ---------------------------------------------------------------------------
//  
void CNATFWTurnSettings::ReadSettingsL( TUint32 aDomainKey,
    const CNATFWCenRepHandler& aRepHandler )
    {
    __NATSETTINGS( "CNATFWTurnSettings::ReadSettingsL" )
    
    RArray<TUint32> serverKeys;
    CleanupClosePushL( serverKeys );
    
    TBool sharedSecretNotEnabled;
    TBool sharedSecretEnabled;
    
    // read sharedsecret enabled
    if ( KErrNone != aRepHandler.Read( KUNSAFProtocolsDomainSharedSecretNotSupported |
        aDomainKey, sharedSecretNotEnabled ) )
        {
        sharedSecretEnabled = KNATFWDefaultUseSharedSecret;
        }
    else
        {
        sharedSecretEnabled = !sharedSecretNotEnabled;
        }
            
    // read server settings
    TInt err = aRepHandler.FindServerKeys(
        KUNSAFProtocolsTURNServerTableMask | aDomainKey, serverKeys );
        
    TInt serverCount = serverKeys.Count();
    
    if ( KErrNone == err && serverCount > 0 )
        {
        for( TInt i( 0 ); i < serverCount; i++ )
            {
            CNATFWServerSettings* serverSettings = CNATFWServerSettings::NewLC(
                KNullDesC8,
                KNATFWDefaultTURNServerPort,
                KNullDesC8,
                KNullDesC8,
                sharedSecretEnabled );
                
            TUint32 key = serverKeys[i] | aDomainKey;
            serverSettings->ReadSettingsL( key, aRepHandler );
            iServerArray->AppendL( serverSettings );
            CleanupStack::Pop( serverSettings );
            }
        }
    else
        {
        if ( KErrNotFound == err )
            {
             __NATSETTINGS( "Server settings not found" )
            }
        else
            {
            User::Leave( err );
            }
        }
    CleanupStack::PopAndDestroy( &serverKeys );
    
    // read LatestConnectedTurnServerAddress and possible port
    TInt port = 0;

    HBufC8* tempBufPointer = aRepHandler.ReadL(
        KUNSAFProtocolsLatestConnectedTURNServerAddressMask | aDomainKey );
    if ( tempBufPointer ) 
        {
        CleanupStack::PushL( tempBufPointer );
        HBufC8* addr = TNATFWSettingsParser::ParseAddressLC(
            *tempBufPointer, port );
        SetLatestConnectedServerAddrL( *addr );
        SetLatestConnectedServerPort( port );
        CleanupStack::PopAndDestroy( addr );
        CleanupStack::PopAndDestroy( tempBufPointer );
        }
    else
        {
        SetLatestConnectedServerAddrL( KNullDesC8 );
        SetLatestConnectedServerPort( port );
        }
    
    // Read LatestConnectedStunServerPort, replaces previous data if found
    if ( KErrNone == aRepHandler.Read( KUNSAFProtocolsLatestConnectedTURNServerPortMask |
        aDomainKey, port ) )
        {
        SetLatestConnectedServerPort( port );
        }

    // read retransmission timeout
    if ( KErrNone != aRepHandler.Read( KUNSAFProtocolsTurnRetransmissionTimeoutMask |
        aDomainKey, iRto ) )
        {
        iRto = KNATFWDefaultRtoValue;
        }
    }


// ---------------------------------------------------------------------------
// From class MNATFWTurnSettings.
// CNATFWTurnSettings::GetTurnServerArrayL
// ---------------------------------------------------------------------------
//
void CNATFWTurnSettings::GetTurnServerArrayL(
    RPointerArray<MNATFWServerSettings>& aServers ) const
    {
    TInt count = iServerArray->Count();
    
    for ( TInt i( 0 ); i < count; i++ )
        {
        aServers.AppendL( iServerArray->At( i ) );
        }
    }


// ---------------------------------------------------------------------------
// From class MNATFWTurnSettings.
// CNATFWServerSettings::RetransmissionTimeout
// ---------------------------------------------------------------------------
//
TUint CNATFWTurnSettings::RetransmissionTimeout() const
    {
    return iRto;
    }


// ---------------------------------------------------------------------------
// From class MNATFWTurnSettings.
// CNATFWTurnSettings::LatestConnectedServerAddr
// ---------------------------------------------------------------------------
//
 const TDesC8& CNATFWTurnSettings::LatestConnectedServerAddr() const
    {
    return *iLatestConnectedServerAddr;
    }


// ---------------------------------------------------------------------------
// From class MNATFWTurnSettings.
// CNATFWTurnSettings::LatestConnectedServerPort
// ---------------------------------------------------------------------------
//
TInt CNATFWTurnSettings::LatestConnectedServerPort() const
    {
    return iLatestConnectedServerPort;
    }