/*

* 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:  Receives and stores NAT/FW Traversal settings internally.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <CWPAdapter.h>

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <wpnatfwtraversaladapter.rsg>

#include <WPAdapterUtil.h> // Adapter utils

#include <utf.h> // Unicode conversion

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmconnectionmethoddef.h>

#include "natfwdomainspecificitem.h"

#include "natfwiapspecificitem.h"

#include "natfwtraversaladapter.h"

#include "wpnatfwitem.h"

#include "wpnatfwdebug.h"

#include "natfwdefaults.h"

#include "stunserveritem.h"

#include "turnserveritem.h"

// Central Repository keys for NAT-FW Traversal settings

#include <unsafprotocolscrkeys.h>

#include "centralrepository.h"

// LOCAL CONSTANTS

// Application related constants

_LIT( KNATFWTraversalAdapterName, "WPNATFWTraversalAdapter");

_LIT( KNATFWAppID,                "w902E" ); // OMA CP AC document for NATFW.

_LIT8( KNATFWAppID8,              "w902E" );

// Network (domain) specific settings.

_LIT( KNetwork,                   "NW" ); 

_LIT( KAdditionalStun,            "ADDITIONALSTUN" );

_LIT( KStunsrvaddr,               "STUNSRVADDR" );

_LIT( KStunsrvport,               "STUNSRVPORT" );

_LIT( KNatRefreshTcp,             "NATREFRESHTCP" );

_LIT( KNatRefreshUdp,             "NATREFRESHUDP" );

_LIT( KCrlfRefresh,               "CRLFREFRESH" );

// Access point specific settings.

_LIT( KNatIap,                    "NATIAP" );

_LIT( KToNapId,                   "TONAPID" );

_LIT( KRefreshTcp,                "REFRESHTCP" );

_LIT( KRefreshUdp,                "REFRESHUDP" );

_LIT( KStunRetransmit,            "STUNRETRANSMIT" );

// Network (domain) specific settings.

_LIT( KStunSharedSecret,          "SHAREDSECRET" );

_LIT( KPortPoolStart,             "SPRANGE" );

_LIT( KPortPoolEnd,               "EPRANGE" );

// ICE specific settings.

_LIT( KIce,                       "ICE" );

_LIT( KNatUtilities,              "NATUTILITIES" );

_LIT( KHostPref,                  "HOSTPREF" );

_LIT( KServerReflexivePref,       "SERVERREFPREF" );

_LIT( KRelayPref,                 "RELAYPREF" );

_LIT( KPeerReflexivePref,         "PEERREFPREF" );

_LIT( KIPv4Pref,                  "IPV4PREF" );

_LIT( KIPv6Pref,                  "IPV6PREF" );

_LIT( KVPNPref,                   "VPNPREF" );

_LIT( KUDPPref,                   "UDPPREF" );

_LIT( KTCPPref,                   "TCPPREF" );

_LIT( KTCPActivePref,             "TCPACTIVEPREF" );

_LIT( KTCPPassivePref,            "TCPPASSIVEPREF" );

_LIT( KTCPSimultaneousOpenPref,   "TCPSIMULTPREF" );

// TURN specific settings.

_LIT( KTurnServer,                "TURNSERVER" );

_LIT( KTurnSrvAddr,               "TURNSRVADDR" );

_LIT( KTurnSrvPort,               "TURNSRVPORT" );

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

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

// CNATFWTraversalAdapter::CNATFWTraversalAdapter

//

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

//

CNATFWTraversalAdapter::CNATFWTraversalAdapter() : CWPAdapter()

    {

    }

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

// CNATFWTraversalAdapter::ConstructL

//

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

//

void CNATFWTraversalAdapter::ConstructL()

    {

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

    // read default title and name from resources.

    TFileName fileName;

    Dll::FileName( fileName );

    iDefaultName = WPAdapterUtil::ReadHBufCL( fileName, 

        KNATFWTraversalAdapterName, 

        R_QTN_SM_DEFAULT_NAME_NATFW );

    iTitle = WPAdapterUtil::ReadHBufCL( fileName, 

        KNATFWTraversalAdapterName, 

        R_QTN_SM_HEAD_NATFW );

    iCharacteristicNw             = EFalse;

    iCharacteristicIce            = EFalse;

    iCharacteristicTurn           = EFalse;

    iCharacteristicNatIap         = EFalse;

    iCharacteristicTurnServer     = EFalse;

    iCharacteristicAdditionalStun = EFalse;

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

    }

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

// CNATFWTraversalAdapter::NewL

// Static constructor.

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

//

CNATFWTraversalAdapter* CNATFWTraversalAdapter::NewL()

    {

    CNATFWTraversalAdapter* self = new ( ELeave ) CNATFWTraversalAdapter;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNATFWTraversalAdapter::~CNATFWTraversalAdapter

//

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

//

CNATFWTraversalAdapter::~CNATFWTraversalAdapter()

    {

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

    delete iDefaultName;

    delete iTitle;

    iDatas.ResetAndDestroy();

    iDatas.Close();

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

    }

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

// CNATFWTraversalAdapter::ContextExtension

//

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

//

TInt CNATFWTraversalAdapter::ContextExtension( 

    MWPContextExtension*& aExtension )

    {

    aExtension = this;

    return KErrNone;

    }

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

// CNATFWTraversalAdapter::VisitLinkL

//

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

//

void CNATFWTraversalAdapter::VisitLinkL( CWPCharacteristic& aLink )

    {

    DBG_PRINT( "CNATFWTraversalAdapter::VisitLinkL - begin" );

    if ( ( KWPNapDef == aLink.Type() ) && iCurrentIapItem 

        && !iCurrentIapItem->NapDef() )

        {

        iCurrentIapItem->SetNapDef( &aLink );

        }

    DBG_PRINT( "CNATFWTraversalAdapter::VisitLinkL - end" );

    }

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

// CNATFWTraversalAdapter::SaveDataL

//

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

//

const TDesC8& CNATFWTraversalAdapter::SaveDataL( TInt aIndex ) const

    {

    return iDatas[aIndex]->SaveData();

    }

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

// CNATFWTraversalAdapter::DeleteL

//

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

//

void CNATFWTraversalAdapter::DeleteL( const TDesC8& aSaveData )

    {

    DBG_PRINT( "CNATFWTraversalAdapter::DeleteL - begin" );

    // Central Repository for NAT-FW Traversal settings.

    CRepository* rep = CRepository::NewLC( KCRUidUNSAFProtocols );

    TInt step( 0 );

    // Delete all keys that are stored.

    while ( step < aSaveData.Length() )

        {

        TUint32 key = DesToTUint( aSaveData.Mid( step, KMaxCharsInTUint32 ) );

        key &= KUNSAFProtocolsTableMask;

        TUint32 errorKey;

        rep->Delete( key, KUNSAFProtocolsTableMask, errorKey );

        step += KMaxCharsInTUint32;

        }

    CleanupStack::PopAndDestroy( rep );

    DBG_PRINT( "CNATFWTraversalAdapter::DeleteL - end" );

    }

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

// CNATFWTraversalAdapter::Uid

//

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

//

TUint32 CNATFWTraversalAdapter::Uid() const

    {

    return iDtor_ID_Key.iUid; 

    }

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

// CNATFWTraversalAdapter::DetailsL

//

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

//

TInt CNATFWTraversalAdapter::DetailsL( 

    TInt /*aItem*/, MWPPairVisitor& /*aVisitor */ )

    {

    return KErrNotSupported;

    }

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

// CNATFWTraversalAdapter::ItemCount

//

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

//

TInt CNATFWTraversalAdapter::ItemCount() const

    {

    return iDatas.Count();

    }

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

// CNATFWTraversalAdapter::SummaryTitle

//

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

//

const TDesC16& CNATFWTraversalAdapter::SummaryTitle( TInt /*aIndex*/ ) const

    {

    return *iTitle;

    }

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

// CNATFWTraversalAdapter::SummaryText

//

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

//

const TDesC16& CNATFWTraversalAdapter::SummaryText( TInt aIndex ) const

    {

    // If there is no value for NAME parameter the default value is set here.

    if ( 0 == iDatas[aIndex]->Name().Length() )

        {

        TRAP_IGNORE( iDatas[aIndex]->SetNameL( iDefaultName->Des() ) );

        }

    return iDatas[aIndex]->Name();

    }

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

// CNATFWTraversalAdapter::SaveL

//

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

//

void CNATFWTraversalAdapter::SaveL( TInt aIndex )

    {

    DBG_PRINT( "CNATFWTraversalAdapter::SaveL - begin" );

    CWPNATFWItem* cNATFWItem = iDatas[aIndex];

    const TInt iapItemCount( iDatas[aIndex]->IAPItems().Count() );

    for ( TInt counter = 0; counter < iapItemCount; counter++ )

        {

        // Set access point ID to current IAP item (access point is always

        // stored before NAT/FW settings).

        CNATFWIAPSpecificItem* cIapItem = iDatas[aIndex]->IAPItems()[counter];

        if ( cIapItem->NapDef() )

            {

            // Get WAP ID.

            TPckgBuf<TUint32> uid;

            uid.Copy( cIapItem->NapDef()->Data( 0 ) );

            TUint32 wapId( uid() );

            // Get corresponding IAP ID.

            TUint32 iapId = IapIdFromWapIdL( wapId );

            cIapItem->SetIAPId( iapId );

            }// if 

        cIapItem = NULL;    

        }

    cNATFWItem->StoreL();

    cNATFWItem = NULL;

    DBG_PRINT( "CNATFWTraversalAdapter::SaveL - end" );

    }

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

// CNATFWTraversalAdapter::CanSetAsDefault

//

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

//

TBool CNATFWTraversalAdapter::CanSetAsDefault( TInt /*aIndex*/ ) const

    {

    // NATFW profile cannot be set as default via OMA CP.

    return EFalse;

    }

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

// CNATFWTraversalAdapter::SetAsDefaultL

//

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

//

void CNATFWTraversalAdapter::SetAsDefaultL( TInt /*aIndex*/ )

    {

    // NATFW profile cannot be set as default via OMA CP.

    }

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

// CNATFWTraversalAdapter::VisitL

//

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

//

void CNATFWTraversalAdapter::VisitL( CWPCharacteristic& aCharacteristic )

    {

    DBG_PRINT( "CNATFWTraversalAdapter::VisitL( characteristic ) - begin" );

    switch( aCharacteristic.Type() )

        {

        // Core NATFW settings.

        case KWPApplication:

            {

            iCurrentNATFWItem = CWPNATFWItem::NewL();

            aCharacteristic.AcceptL( *this );

            // If NATFW settings, append the item into array.

            if ( KNATFWAppID() == iAppID ) 

                {

                User::LeaveIfError( iDatas.Append( iCurrentNATFWItem ) );

                }

            else // Else the settings are no longer of type NATFW.

                {

                delete iCurrentNATFWItem;

                iCurrentNATFWItem             = NULL;

                iCharacteristicNw             = EFalse;

                iCharacteristicIce            = EFalse;

                iCharacteristicTurn           = EFalse;

                iCharacteristicNatIap         = EFalse;

                iCharacteristicTurnServer     = EFalse;

                iCharacteristicAdditionalStun = EFalse;

                }

            break;

            }

        case KWPNamedCharacteristic:

            {

            // Domain specific settings.

            if ( aCharacteristic.Name().Compare( KNetwork() ) == 0 )

                {

                iCurrentDomainItem = CNATFWDomainSpecificItem::NewL();

                iCharacteristicNw = ETrue;

                iCurrentDomainItem->SetDefaultValuesL();

                aCharacteristic.AcceptL( *this ); 

                // Ownership transfer:

                iCurrentNATFWItem->AddDomainSpecificL( iCurrentDomainItem );

                }

            // IAP specific settings.

            else if ( aCharacteristic.Name().Compare( KNatIap() ) == 0 )

                {

                iCurrentIapItem = CNATFWIAPSpecificItem::NewL();

                iCharacteristicNatIap = ETrue;

                // Set defaults for IAP specific item.

                iCurrentIapItem->SetSTUNRetransmitTimer(

                    KDefaultSTUNRetransmitTimer );

                // Default values for UDP and TCP refresh intervals are set in

                // NATFWItem if there are no values for either Domain or IAP

                // specific items.

                iCurrentIapItem->SetIntervalUDP( KNotSet );

                iCurrentIapItem->SetIntervalTCP( KNotSet );

                aCharacteristic.AcceptL( *this );

                // Ownership transfer:

                iCurrentNATFWItem->AddIAPSpecificL( iCurrentIapItem );

                }

            // ICE specific settings.

            else if ( 0 == aCharacteristic.Name().Compare( KIce() ) )

                {

                if ( !iCurrentDomainItem )

                    {

                    break;

                    }

                else

                    {

                    iCharacteristicIce = ETrue;

                    aCharacteristic.AcceptL( *this );

                    }

                }

            // TURNSERVER specific settings.

            else if ( 0 == aCharacteristic.Name().Compare( KTurnServer() ) )

                {

                if ( !iCurrentDomainItem )

                    {

                    break;

                    }

                else

                    {

                    iCurrentTurnServer = CWPTurnServerItem::NewL();

                    iCharacteristicTurnServer = ETrue;

                    aCharacteristic.AcceptL( *this );

                    // Ownership transfer:

                    iCurrentDomainItem->AddTurnServerItemL( 

                        iCurrentTurnServer );

                    }

                }

            // ADDITIONALSTUN specific settings.

            else if ( 0 == aCharacteristic.Name().Compare( 

                KAdditionalStun() ) )

                {

                if ( !iCurrentDomainItem )

                    {

                    break;

                    }

                else

                    {

                    iCurrentStunServer = CWPStunServerItem::NewL();

                    iCharacteristicAdditionalStun = ETrue;

                    aCharacteristic.AcceptL( *this );

                    // Ownership transfer:

                    iCurrentDomainItem->AddStunServerItemL( 

                        iCurrentStunServer );

                    }

                }

            break; 

            }

        default:

            break;

        }

    DBG_PRINT( "CNATFWTraversalAdapter::VisitL( characteristic ) - end" );

    }

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

// CNATFWTraversalAdapter::VisitL

//

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

//

void CNATFWTraversalAdapter::VisitL( CWPParameter& aParameter )

    {

    DBG_PRINT( "CNATFWTraversalAdapter::VisitL( parameter ) - begin" );

    // tmpValue holds the value converted from Unicode to UTF8.

    HBufC8* tmpValue = HBufC8::NewLC( aParameter.Value().Length() ); // CS:1

    TPtr8 ptrTmpValue( tmpValue->Des() );

    CnvUtfConverter::ConvertFromUnicodeToUtf8( ptrTmpValue, 

        aParameter.Value() );

    switch( aParameter.ID() )

        {

        case EWPParameterAppID:

            {

	        iAppID.Set( aParameter.Value() );

            break;

            }

        case EWPParameterDomain:

            {

            if ( iCurrentDomainItem )

                {

                iCurrentDomainItem->SetDomainL( tmpValue->Des() );

                }

            break;

            }    

        // Here at case 0 are handled the NAT/FW parameters that are

        // extensions to OMA Client Provisioning parameter set.

        case 0:

            // NW/STUNSRVADDR

            if ( 0 == aParameter.Name().Compare( KStunsrvaddr ) )

                {

                if ( iCharacteristicNw )

                    {

                    // Domain STUN server settings.

                    if ( !iCharacteristicAdditionalStun )

                        {

                        iCurrentDomainItem->SetSTUNServerAddrL( 

                            tmpValue->Des() );

                        }

                    // Additional STUN server settings.

                    else

                        {

                        iCurrentStunServer->SetStunSrvAddrL(

                            tmpValue->Des() );

                        }

                    }

                }

            // NW/STUNSRVPORT

            else if ( 0 == aParameter.Name().Compare( KStunsrvport ) )

                {

                if ( iCharacteristicNw )

                    {

                    // Domain STUN server settings.

                    if ( !iCharacteristicAdditionalStun )

                        {

                        iCurrentDomainItem->SetSTUNServerPort( 

                            DesToInt( tmpValue->Des() ) );

                        }

                    // Additional STUN server settings.

                    else

                        {

                        iCurrentStunServer->SetStunSrvPort( DesToInt( 

                            tmpValue->Des() ) );

                        }

                    }

                }

            // NW/NATREFRESHTCP

            else if ( 0 == aParameter.Name().Compare( KNatRefreshTcp ) )