/*

* Copyright (c) 2006 - 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:  Holds and stores one NAT/FW settings item.

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <e32cmn.h>

#include    <charconv.h>

#include    <CWPCharacteristic.h>

#include    "WPAdapterUtil.h"

//#include    "versit.h"

// Central Repository keys for NAT-FW Traversal settings

#include    <centralrepository.h>

#include    <unsafprotocolscrkeys.h>

#include    "wpnatfwitem.h"

#include    "natfwdomainspecificitem.h"

#include    "natfwiapspecificitem.h"

#include    "natfwdefaults.h"

#include    "wpnatfwdebug.h"

#include    "stunserveritem.h"

#include    "turnserveritem.h"

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

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

// CWPNATFWItem::NewL

//

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

//

CWPNATFWItem* CWPNATFWItem::NewL() 

    {

    CWPNATFWItem* self = new (ELeave) CWPNATFWItem;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWPNATFWItem::ConstructL

//

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

//

void CWPNATFWItem::ConstructL()

    {

    DBG_PRINT( "CWPNATFWItem::ConstructL - begin" );

    // Initialization with empty string or KNotSaved

    iItemId                          = TUint( KNotSaved );

    iName                            = HBufC::NewL( 0 );

    iAppRef                          = HBufC8::NewL( 0 );

    iSaveData                        = HBufC8::NewL( 0 );

    iSavedDomainId                   = HBufC8::NewL( 0 );

    DBG_PRINT( "CWPNATFWItem::ConstructL - end" );

    }

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

// CWPNATFWItem::~CWPNATFWItem

//

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

//

CWPNATFWItem::~CWPNATFWItem()

    {

    DBG_PRINT( "CWPNATFWItem::~CWPNATFWItem - begin" );

    iDomainItems.ResetAndDestroy();

    iDomainItems.Close();

    iIAPItems.ResetAndDestroy();

    iIAPItems.Close();

    delete iName;

    delete iAppRef;

    delete iSaveData;

    delete iSavedDomainId;

    DBG_PRINT( "CWPNATFWItem::~CWPNATFWItem - end" );

    }

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

// CWPNATFWItem::SetItemId

//

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

//

void CWPNATFWItem::SetItemId( TUint aItemId )

    {

    iItemId = aItemId;

    }

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

// CWPNATFWItem::SetNameL

//

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

//

void CWPNATFWItem::SetNameL( const TDesC& aName )

    {

    delete iName;

    iName = NULL;

    iName = aName.AllocL();

    }

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

// CWPNATFWItem::SetAppRefL

//

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

//

void CWPNATFWItem::SetAppRefL( const TDesC8& aAppRef )

    {

    delete iAppRef;

    iAppRef = NULL;

    iAppRef = aAppRef.AllocL();

    }

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

// CWPNATFWItem::AppRef

//

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

//

const TDesC8& CWPNATFWItem::AppRef() const

    {

    return *iAppRef;

    }

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

// CWPNATFWItem::AddDomainSpecific

//

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

//

void CWPNATFWItem::AddDomainSpecificL( CNATFWDomainSpecificItem* 

    aNATFWDomainSpecificItem )

    {

    __ASSERT_ALWAYS( aNATFWDomainSpecificItem != NULL, 

        User::Leave( KErrArgument ) );

    iDomainItems.AppendL( aNATFWDomainSpecificItem );

    }

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

// CWPNATFWItem::AddIAPSpecific

//

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

//

void CWPNATFWItem::AddIAPSpecificL( CNATFWIAPSpecificItem* 

    aNATFWIAPSpecificItem )

    {

    __ASSERT_ALWAYS( aNATFWIAPSpecificItem != NULL,

        User::Leave( KErrArgument ) );

    iIAPItems.AppendL( aNATFWIAPSpecificItem );

    }

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

// CWPNATFWItem::IAPItems

//

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

//

const RPointerArray<CNATFWIAPSpecificItem>& CWPNATFWItem::IAPItems() const

    {

    return iIAPItems;

    }

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

// CWPNATFWItem::Name

//

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

//

const TDesC& CWPNATFWItem::Name() const

    {

    return *iName;

    }

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

// CWPNATFWItem::ItemId

//

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

//

TUint CWPNATFWItem::ItemId() const

    {

    return iItemId;

    }

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

// CWPNATFWItem::CreateIceSettingsL

//

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

//

void CWPNATFWItem::CreateIceSettingsL( CRepository* aRepository, TInt aIndex,

    TUint aKey )

    {

    __ASSERT_ALWAYS( aRepository != NULL, User::Leave( KErrBadHandle ) );

    DBG_PRINT( "CWPNATFWItem::CreateIceSettingsL - begin" );

    TUint32 currentDomainKey( KErrNone );

    currentDomainKey = aKey|KUNSAFProtocolsDomainMask;

    currentDomainKey &= KUNSAFProtocolsKeyMask;

    // ==============================

    // ICE: NatUtilities

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsNATUtilities,

        iDomainItems[aIndex]->NatUtilities() ) );

    // ==============================

    // ICE: Host preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsHostPref,

        iDomainItems[aIndex]->HostPref() ) );

    // ==============================

    // ICE: Server-reflexive preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsServerRefPref,

        iDomainItems[aIndex]->ServerRefPref() ) );

    // ==============================

    // ICE: Relay-preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsRelayPref,

        iDomainItems[aIndex]->RelayPref() ) );

    // ==============================

    // ICE: Peer-reflexive preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsPeerRefPref,

        iDomainItems[aIndex]->PeerRefPref() ) );

    // ==============================

    // ICE: IPv4 preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsIPV4Pref,

        iDomainItems[aIndex]->IPv4Pref() ) );

    // ==============================

    // ICE: IPv6 preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsIPV6Pref,

        iDomainItems[aIndex]->IPv6Pref() ) );

    // ==============================

    // ICE: VPN preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsVPNPref,

        iDomainItems[aIndex]->VpnPref() ) );

    // ==============================

    // ICE: UDP preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsUDPPref,

        iDomainItems[aIndex]->UdpPref() ) );

    // ==============================

    // ICE: TCP preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsTCPPref,

        iDomainItems[aIndex]->TcpPref() ) );

    // ==============================

    // ICE: TCP-active preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsTCPActivePref,

        iDomainItems[aIndex]->TcpActivePref() ) );

    // ==============================

    // ICE: TCP-passive preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsTCPPassivePref,

        iDomainItems[aIndex]->TcpPassivePref() ) );

    // ==============================

    // ICE: TCP-simultaneous-open preference

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsTCPSimultPref,

        iDomainItems[aIndex]->TcpSimultPref() ) );

    DBG_PRINT( "CWPNATFWItem::CreateIceSettingsL - end" );

    }

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

// CWPNATFWItem::CreateTurnSettingsL

//

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

//

void CWPNATFWItem::CreateTurnSettingsL( CRepository* aRepository, TInt aIndex,

    TUint aKey )

    {

    __ASSERT_ALWAYS( aRepository != NULL, User::Leave( KErrBadHandle ) );

    DBG_PRINT( "CWPNATFWItem::CreateTurnSettingsL - begin" );

    TUint32 currentDomainKey( KErrNone );

    currentDomainKey = aKey|KUNSAFProtocolsDomainMask;

    currentDomainKey &= KUNSAFProtocolsKeyMask;

    iDomainItems[aIndex]->StoreTurnServerItemsL( aRepository, 

        currentDomainKey );

    DBG_PRINT( "CWPNATFWItem::CreateTurnSettingsL - end" );

    }

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

// CWPNATFWItem::CreateStunSettingsL

//

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

//

void CWPNATFWItem::CreateStunSettingsL( CRepository* aRepository, TInt aIndex,

    TUint aKey, HBufC8* aTmpSavedata )

    {

    __ASSERT_ALWAYS( aRepository != NULL, User::Leave( KErrBadHandle ) );

    __ASSERT_ALWAYS( aTmpSavedata != NULL, User::Leave( KErrArgument ) );

    DBG_PRINT( "CWPNATFWItem::CreateStunSettingsL - begin" );

    TUint32 currentDomainKey( KErrNone );

    currentDomainKey = aKey|KUNSAFProtocolsDomainMask;

    currentDomainKey &= KUNSAFProtocolsKeyMask;

    TUint32 currentNewDomainKey = currentDomainKey;

    currentNewDomainKey = aKey|KUNSAFProtocolsFieldTypeMask;

    currentNewDomainKey ^= KUNSAFProtocolsFieldTypeMask;

    TUint32 stunKey;

    stunKey = KUNSAFProtocolsSubTableFieldTypeMask;

    stunKey ^= KUNSAFProtocolsSubTableFieldTypeMask;

    stunKey |= currentNewDomainKey;

    // Store "additional STUN servers".

    iDomainItems[aIndex]->StoreStunServerItemsL( aRepository, stunKey, 

        currentNewDomainKey );

    // ==============================

    // STUNServerAddress

    // ==============================

    // 

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsSTUNServerMask|currentDomainKey, 

        iDomainItems[aIndex]->GetSTUNAddr() ) );

    // Set the same value into STUN server table.

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsSTUNAddressMask|stunKey,

        iDomainItems[aIndex]->GetSTUNAddr() ) );

    // ==============================

    // STUNServerPort

    // ==============================

    //  

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsSTUNServerPortMask|currentDomainKey, 

        ( TInt )iDomainItems[aIndex]->GetSTUNPort() ) );

    // Set the same value into STUN server table.

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsSTUNPortMask|stunKey,

        ( TInt )iDomainItems[aIndex]->GetSTUNPort() ) );

    // ==============================

    // NATRefreshUDP

    // ==============================

    // 

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsDomainIntervalUDPMask|currentDomainKey, 

        iDomainItems[aIndex]->GetNATRefreshUDP() ) );

    // ==============================

    // NATRefreshTCP

    // ==============================

    // 

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsDomainIntervalTCPMask|currentDomainKey, 

        iDomainItems[aIndex]->GetNATRefreshTCP() ) );

    // ==============================

    // EnableCRLFRefresh

    // ==============================

    //  

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsDomainEnableCRLFRefresh|currentDomainKey,

        iDomainItems[aIndex]->GetEnableCRLFRefresh() ) );

    // ==============================

    // STUNServerUsername

    // ==============================

    // 

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsSTUNUsernameMask|stunKey, 

        iDomainItems[aIndex]->GetSTUNUsername() ) );

    // ==============================

    // STUNServerPassword

    // ==============================

    // 

    User::LeaveIfError( aRepository->Create( 

        KUNSAFProtocolsSTUNPasswordMask|stunKey, 

        iDomainItems[aIndex]->GetSTUNPassword() ) );

    // ==============================

    // STUNSharedSecret

    // ==============================

    //

    User::LeaveIfError( aRepository->Create( currentDomainKey|

        KUNSAFProtocolsDomainSharedSecretNotSupported,

        iDomainItems[aIndex]->DisableStunSharedSecret() ) );

    // ==============================

    // StartPortRange

    // ==============================

    //

    User::LeaveIfError( aRepository->Create( 

        currentDomainKey|KUNSAFProtocolsPortPoolStartPortMask,

        iDomainItems[aIndex]->StartPortRange() ) );

    // ==============================

    // EndPortRange

    // ==============================

    //

    User::LeaveIfError( aRepository->Create( 

        currentDomainKey|KUNSAFProtocolsPortPoolEndPortMask,

        iDomainItems[aIndex]->EndPortRange() ) );

    // ==============================

    // UsedNATProtocol

    // ==============================

    //

    User::LeaveIfError( aRepository->Create(

        currentDomainKey|KUNSAFProtocolsUsedNATProtocolMask,

        iDomainItems[aIndex]->UsedNatProtocol() ) );

    if ( 0 == aIndex )

        {

        HBufC8* tmpId = HBufC8::NewL( KMaxCharsInTUint32 );

        // APPREF is always reference to first domain specific

        // characteristic.

        tmpId->Des().AppendNum( 

            currentDomainKey|KUNSAFProtocolsDomainMask );

        delete iSavedDomainId;

        iSavedDomainId = NULL;

        iSavedDomainId = tmpId;

        tmpId = NULL;    

        }

    DBG_PRINT( "CWPNATFWItem::CreateStunSettingsL - end" );

    }

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

// CWPNATFWItem::CreateIapSettingsL

//

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

//

void CWPNATFWItem::CreateIapSettingsL( CRepository* aRepository,

    HBufC8* aTmpSavedata )

    {

    __ASSERT_ALWAYS( aRepository != NULL, User::Leave( KErrBadHandle ) );

    __ASSERT_ALWAYS( aTmpSavedata != NULL, User::Leave( KErrArgument ) );

    DBG_PRINT( "CWPNATFWItem::CreateIapSettingsL - begin" );

    for ( TInt counter = 0; counter < iIAPItems.Count(); counter++ )

        {

        RArray<TUint32> keys;

        CleanupClosePushL( keys );

        // Get next free IAP key

        aRepository->FindL( KUNSAFProtocolsIAPIdMask,

            KUNSAFProtocolsFieldTypeMask, keys );

        TInt keyCount = keys.Count();   

        TUint32 tmp ( 0 );

        if ( keyCount > 0 )

            {

            tmp = keys[keyCount - 1] + 1;

            }

        else

            {

            tmp = KUNSAFProtocolsIAPTableMask;

            }

        TUint32 currentIAPKey( KErrNone );

        currentIAPKey = tmp|KUNSAFProtocolsIAPIdMask;

        currentIAPKey &= KUNSAFProtocolsKeyMask;

        // ==============================

        // IAPId

        // ==============================

        //

        User::LeaveIfError( aRepository->Create(

            currentIAPKey|KUNSAFProtocolsIAPIdMask, 

            (TInt)iIAPItems[counter]->GetIAPId() ) );

        aTmpSavedata->Des().AppendNumFixedWidth( 

            currentIAPKey|KUNSAFProtocolsIAPIdMask, 

            EDecimal, KMaxCharsInTUint32 );

        // ==============================

        // IntervalUDP

        // ==============================

        //

        // If there are no domain entries and no value for UDP