/*

* 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 "settingstore.h"

#include <unsafprotocolscrkeys.h>

#include "datadepository.h"

#include "cnatfwstunsettings.h"

#include "cnatfwturnsettings.h"

#include <mnatfwserversettings.h>

#include "natfwdefaultsettingsvalues.h"

const TUint KDefaultGranularity = 1;

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

// CSettingStore::CSettingStore

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

// 

CSettingStore::CSettingStore( TUint aIapId ) :

    iIapId( aIapId )

    {

    //domain

    iRefreshIntervalUdp = KNATFWDefaultRefreshIntervalUdp;

    iRefreshIntervalTcp = KNATFWDefaultRefreshIntervalTcp;

    iCrlfRefresEnabled = KNATFWDefaultCRLFRefreshEnabled;

    iUseSharedSecret = KNATFWDefaultUseSharedSecret;

    iStartPort = KNATFWDefaultPortPoolStartPort;

    iEndPort = KNATFWDefaultPortPoolEndPort;

    //ICE

    iHostPref = KNATFWDefaultlHostPref;

    iServerReflexivePref = KNATFWDefaultServerRefPref;

    iRelayPref = KNATFWDefaultRelayPref;

    iPeerReflexivePref = KNATFWDefaultPeerRefPref;

    iIpv4AddrFamilyPref = KNATFWDefaultIPV4Pref;

    iIpv6AddrFamilyPref = KNATFWDefaultIPV6Pref;

    iVpnInterfacePref = KNATFWDefaultVPNPref;

    iUdpTransportPref = KNATFWDefaultUDPPref;

    iTcpTransportPref = KNATFWDefaultTCPPref;

    iTcpDirActivePref = KNATFWDefaultTCPActivePref;

    iTcpDirPassivePref = KNATFWDefaultTCPPassivePref;

    iTcpDirSimultaneousOpenPref = KNATFWDefaultTCPSimultPref;

    // Iap

    iIapRefreshIntervalUdp = KNATFWDefaultIapRefreshIntervalUdp;

    iIapRefreshIntervalTcp = KNATFWDefaultIapRefreshIntervalTcp;

    iIapStunRetransmitTimer = KNATFWDefaultStunRetransmitTimer;

    }

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

// CSettingStore::ConstructL

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

//  

void CSettingStore::ConstructL( const TDesC8& aDomain )

    {

    iDomain = aDomain.AllocL();

    iRepository = CRepository::NewL( KCRUidUNSAFProtocols );

    iDepository = CDataDepository::NewL( iRepository );

    iUtilityPlugins = KNATFWDefaultIceUsedPlugins().AllocL();

    iAvailableNatProtocols = KNATFWDefaultPriorityOrder().AllocL();

    iStunSettings = CNATFWStunSettings::NewL();

    iTurnSettings = CNATFWTurnSettings::NewL();

    }

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

// CSettingStore::NewL

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

// 

CSettingStore* CSettingStore::NewL( const TDesC8& aDomain, TUint aIapId )

    {

    CSettingStore* self = CSettingStore::NewLC( aDomain, aIapId );

    CleanupStack::Pop(self);

    return self;

    }

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

// CSettingStore::NewL

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

//     

CSettingStore* CSettingStore::NewLC( const TDesC8& aDomain, TUint aIapId )

    {

    CSettingStore* self = new( ELeave ) CSettingStore( aIapId );

    CleanupStack::PushL( self );

    self->ConstructL( aDomain );

    return self;

    }

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

// CSettingStore::~CSettingStore

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

//

CSettingStore::~CSettingStore( )

    {

    delete iDepository;

    delete iRepository;

    delete iDomain;

    delete iAvailableNatProtocols;

    delete iUtilityPlugins;

    delete iStunSettings;

    delete iTurnSettings;

    }

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

// CSettingStore::ReadDomainSettingsKeyL

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

//

TInt CSettingStore::ReadDomainSettingsKeyL( const TDesC8& aDomain, 

    TUint32& aDomainKey ) const

    {

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    TInt err = iRepository->FindEqL( KUNSAFProtocolsDomainMask,

        KUNSAFProtocolsFieldTypeMask, aDomain, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && 1 == count )

        {

        aDomainKey = KUNSAFProtocolsDomainMask ^ keys[0];

        }

    if ( count > 1 )

        {

        err = KErrCorrupt;

        }

    CleanupStack::PopAndDestroy( &keys );

    return err;

    }

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

// CSettingStore::EraseL

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

//

TInt CSettingStore::EraseL( TUint32 aTableMask, TUint32 aFieldTypeMask )

    {

    return iDepository->EraseL( aTableMask, aFieldTypeMask );

    }

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

// CSettingStore::GetDomainKey

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

//

TUint32 CSettingStore::GetDomainKeyL()

    {

    TUint32 domainKey; 

    TInt error = ReadDomainSettingsKeyL( *iDomain, domainKey );

    if( KErrNotFound == error )

        {

        domainKey = CreateNewDomainL( *iDomain );

        }

    else

        {

        User::LeaveIfError( error );

        }

    return domainKey;

    }

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

// CSettingStore::CreateNewDomainL

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

//

TUint32 CSettingStore::CreateNewDomainL( const TDesC8& aDomain )

    {

    TUint32 domainKey = iDepository->CreateNewTableKeyL(

        KUNSAFProtocolsDomainMask, KUNSAFProtocolsFieldTypeMask );

    iDepository->StoreL( KUNSAFProtocolsDomainMask | domainKey, aDomain );

    return domainKey;

    }

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

// CSettingStore::CreateNewIapL

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

//

TUint32 CSettingStore::CreateNewIapL( const TInt aIapId )

    {

    TUint32 iapKey = iDepository->CreateNewTableKeyL(

        KUNSAFProtocolsIAPIdMask, KUNSAFProtocolsFieldTypeMask );

    iDepository->StoreL( KUNSAFProtocolsIAPIdMask | iapKey, aIapId );

    return iapKey;

    }

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

// CSettingStore::CreateServerKeyL

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

//

TUint32 CSettingStore::CreateServerKeyL( TUint32 aDomainKey,

    TUint32 aServerMask )

    {

    const TUint32 KMaskForAllServerSettingsIds = 0xff000fff;

    return iDepository->CreateNewServerKeyL( aServerMask |

        aDomainKey, KMaskForAllServerSettingsIds );

    }

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

// CSettingStore::StoreSettingsL

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

//

void CSettingStore::StoreSettingsL()

    {

    TUint32 domainKey;

    domainKey = GetDomainKeyL();

    RPointerArray<MNATFWServerSettings> stunServers;

    CleanupClosePushL( stunServers );

    iStunSettings->GetStunServerArrayL( stunServers );

    RPointerArray<MNATFWServerSettings> turnServers;

    CleanupClosePushL( turnServers ); 

    iTurnSettings->GetTurnServerArrayL( turnServers );

    TUint32 IapKey = CreateNewIapL( iIapId );

    //Settings

    /************************************************************************/

    //Domain spesific settings

    iDepository->StoreL( KUNSAFProtocolsDomainSharedSecretNotSupported |

        domainKey, !iUseSharedSecret ); 

    iDepository->StoreL( KUNSAFProtocolsPortPoolStartPortMask | domainKey,

        iStartPort );

    iDepository->StoreL( KUNSAFProtocolsPortPoolEndPortMask | domainKey, 

        iEndPort );

    iDepository->StoreL( KUNSAFProtocolsUsedNATProtocolMask | domainKey, 

        *iAvailableNatProtocols );

    iDepository->StoreL( KUNSAFProtocolsDomainEnableCRLFRefresh | domainKey, 

        iCrlfRefresEnabled );

    iDepository->StoreL( KUNSAFProtocolsDomainIntervalUDPMask | domainKey,

        iRefreshIntervalUdp );

    iDepository->StoreL( KUNSAFProtocolsDomainIntervalTCPMask | domainKey, 

        iRefreshIntervalTcp );

    /************************************************************************/

    //STUN settings in the domain

    //STUN Servers

    for ( TInt i( 0 ); i < stunServers.Count(); i++ )

        {

        TUint32 stunServerkey = CreateServerKeyL(

            domainKey, KUNSAFProtocolsSTUNServerTableMask );

        if ( stunServers[i]->Address().Compare( KNullDesC8 ) )

            {

            iDepository->StoreL( KUNSAFProtocolsSTUNAddressMask | domainKey |

                stunServerkey, stunServers[i]->Address() );

            }

        if ( stunServers[i]->Port() != 0 )

            {

            iDepository->StoreL( KUNSAFProtocolsSTUNPortMask | domainKey |

                stunServerkey, stunServers[i]->Port() );

            }

        if ( stunServers[i]->Username().Compare( KNullDesC8 ) )

            {    

            iDepository->StoreL( KUNSAFProtocolsSTUNUsernameMask | domainKey |

                stunServerkey, stunServers[i]->Username() );

            }

        if ( stunServers[i]->Password().Compare( KNullDesC8 ) )

            {

            iDepository->StoreL( KUNSAFProtocolsSTUNPasswordMask | domainKey |

                stunServerkey, stunServers[i]->Password() );

            }

        /*    

        iDepository->StoreL( KUNSAFProtocolsSTUNConnectivityCheckTimeoutMask |

            domainKey | stunServerkey, iStunSettings->RetransmissionTimeout() );

        */

        }

    iDepository->StoreL( KUNSAFProtocolsLatestConnectedSTUNServerAddressMask |

        domainKey, iStunSettings->LatestConnectedServerAddr() );

    iDepository->StoreL( KUNSAFProtocolsLatestConnectedSTUNServerPortMask |

        domainKey, iStunSettings->LatestConnectedServerPort() );

    iDepository->StoreL( KUNSAFProtocolsStunRetransmissionTimeoutMask |

        domainKey, iStunSettings->RetransmissionTimeout() );

    /************************************************************************/

    //TURN settings in the domain

    iDepository->StoreL( KUNSAFProtocolsLatestConnectedTURNServerAddressMask |

        domainKey, iTurnSettings->LatestConnectedServerAddr() );

    iDepository->StoreL( KUNSAFProtocolsLatestConnectedTURNServerPortMask |

        domainKey, iTurnSettings->LatestConnectedServerPort() );

    iDepository->StoreL( KUNSAFProtocolsTurnRetransmissionTimeoutMask |

        domainKey, iTurnSettings->RetransmissionTimeout() );

    //TURN Servers

    for ( TInt i( 0 ); i < turnServers.Count(); i++ )

        {

        TUint32 turnServerkey = CreateServerKeyL(

            domainKey, KUNSAFProtocolsTURNServerTableMask );

        if ( turnServers[i]->Address().Compare( KNullDesC8 ) )

            {    

            iDepository->StoreL( KUNSAFProtocolsTURNAddressMask | domainKey |

                turnServerkey, turnServers[i]->Address() );

            }

        if ( turnServers[i]->Port() != 0 )

            {

            iDepository->StoreL( KUNSAFProtocolsTURNPortMask | domainKey |

                turnServerkey, turnServers[i]->Port() );

            }

        if ( turnServers[i]->Username().Compare( KNullDesC8 ) )

            {    

            iDepository->StoreL( KUNSAFProtocolsTURNUsernameMask | domainKey |

                turnServerkey, turnServers[i]->Username() );

            }

        if ( turnServers[i]->Password().Compare( KNullDesC8 ) )

            {

            iDepository->StoreL( KUNSAFProtocolsTURNPasswordMask | domainKey |

                turnServerkey, turnServers[i]->Password() );

            }

        /* 

        iDepository->StoreL( KUNSAFProtocolsTURNConnectivityCheckTimeoutMask |

            domainKey | turnServerkey, iTurnSettings->RetransmissionTimeout() );

        */

        }

    /************************************************************************/

    //ICE spesific in the Domain settings

    iDepository->StoreL( KUNSAFProtocolsNATUtilities | domainKey,

        *iUtilityPlugins );

    iDepository->StoreL( KUNSAFProtocolsHostPref | domainKey,

       iHostPref );

    iDepository->StoreL( KUNSAFProtocolsServerRefPref | domainKey,

        iServerReflexivePref );    

    iDepository->StoreL( KUNSAFProtocolsRelayPref | domainKey,

        iRelayPref );

    iDepository->StoreL( KUNSAFProtocolsPeerRefPref | domainKey,

        iPeerReflexivePref );

    iDepository->StoreL( KUNSAFProtocolsIPV4Pref | domainKey,

        iIpv4AddrFamilyPref );

    iDepository->StoreL( KUNSAFProtocolsIPV6Pref | domainKey,

        iIpv6AddrFamilyPref );

    iDepository->StoreL( KUNSAFProtocolsVPNPref | domainKey,

        iVpnInterfacePref );

    iDepository->StoreL( KUNSAFProtocolsUDPPref | domainKey,

        iUdpTransportPref );

    iDepository->StoreL( KUNSAFProtocolsTCPPref | domainKey,

        iTcpTransportPref );

    iDepository->StoreL( KUNSAFProtocolsTCPActivePref | domainKey,

        iTcpDirActivePref );

    iDepository->StoreL( KUNSAFProtocolsTCPPassivePref | domainKey,

        iTcpDirPassivePref );

    iDepository->StoreL( KUNSAFProtocolsTCPSimultPref | domainKey,

        iTcpDirSimultaneousOpenPref );

    /************************************************************************/

    //IAP Spesific settings

    iDepository->StoreL( KUNSAFProtocolsIntervalTCPMask | IapKey, 

        iIapRefreshIntervalTcp );

    iDepository->StoreL( KUNSAFProtocolsIntervalUDPMask | IapKey, 

        iIapRefreshIntervalUdp );

    iDepository->StoreL( KUNSAFProtocolsSTUNRetransmitTimerMask | IapKey, 

        iIapStunRetransmitTimer );

    CleanupStack::PopAndDestroy( &turnServers );

    CleanupStack::PopAndDestroy( &stunServers );

    }