/*

* Copyright (c) 2009-2010 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: 

*      Implementation of VPN CmManager Plugin interface implementation 

*      

*

*/

// INCLUDE FILES

#include <commsdattypesv1_1.h>

#include <datamobilitycommsdattypes.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginvpndef.h>

#include <featmgr.h>

#include <publicruntimeids.hrh>

#include "cmpluginvpn.h"

#include "cmmserverdefs.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmpluginvpnTraces.h"

#endif

using namespace CommsDat;

using namespace CMManager;

_LIT( KVpnVirtualBearerName, "vpnbearer" );

_LIT( KVpnVirtualBearerAgent, "vpnconnagt.agt" );

_LIT( KVpnVirtualBearerNif, "tunnelnif" );

static const TInt KVirtualIAPNextLayerRecordIndex = 0;

// constants needed for the virtualbearer table

static const TInt KNoTimeout = -1;

static const TUint32 KLastSessionTimeout = 3;

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

// CCmPluginVpn::NewL

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

//

CCmPluginVpn* CCmPluginVpn::NewL( TCmPluginInitParam* aInitParam )

	{	

    OstTraceFunctionEntry0( CCMPLUGINVPN_NEWL_ENTRY );

	CCmPluginVpn* self = new( ELeave ) CCmPluginVpn( aInitParam );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	OstTraceFunctionExit0( CCMPLUGINVPN_NEWL_EXIT );

	return self;		

	}

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

// CCmPluginVpn::CreateInstanceL

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

//

CCmPluginBaseEng* CCmPluginVpn::CreateInstanceL( TCmPluginInitParam& aInitParam ) const

	{

    OstTraceFunctionEntry0( CCMPLUGINVPN_CREATEINSTANCEL_ENTRY );

    CCmPluginVpn* self = new( ELeave ) CCmPluginVpn( &aInitParam );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	OstTraceFunctionExit0( CCMPLUGINVPN_CREATEINSTANCEL_EXIT );

	return self;				

	}

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

// CCmPluginVpn::~CCmPluginVpn

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

//

CCmPluginVpn::~CCmPluginVpn()

	{

    OstTraceFunctionEntry0( CCMPLUGINVPN_CCMPLUGINVPN_ENTRY );

    ResetBearerRecords();

	OstTraceFunctionExit0( CCMPLUGINVPN_CCMPLUGINVPN_EXIT );

	}

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

// CCmPluginVpn::CCmPluginVpn

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

//

CCmPluginVpn::CCmPluginVpn( TCmPluginInitParam* aInitParam )

	: CCmPluginBaseEng( aInitParam ), iVirtualTableId(0), 

	  iBearerPriorityTableId(0), iVirtualIapNextLayerRecord(NULL)

	{

    OstTraceFunctionEntry0( DUP1_CCMPLUGINVPN_CCMPLUGINVPN_ENTRY );

    iBearerType = KPluginVPNBearerTypeUid;

    OstTraceFunctionExit0( DUP1_CCMPLUGINVPN_CCMPLUGINVPN_EXIT );

	}

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

// CCmPluginVpn::ConstructL

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

//

void CCmPluginVpn::ConstructL()

	{    

    OstTraceFunctionEntry0( CCMPLUGINVPN_CONSTRUCTL_ENTRY );

    if (!FeatureManager::FeatureSupported( KFeatureIdFfVpnClient ) )

        {   

        User::Leave( KErrNotSupported );

        }

    TRAP_IGNORE( iVirtualTableId = 

                        CCDVirtualIAPNextLayerRecord::TableIdL( iSession ) );       

    if( !iVirtualTableId )

        {

        iVirtualTableId = CCDVirtualIAPNextLayerRecord::CreateTableL( iSession );

        }

    TRAP_IGNORE( iBearerPriorityTableId =

            CCDGlobalBearerTypePriorizationRecord::TableIdL( iSession ) );

    if ( !iBearerPriorityTableId )

        {

        iBearerPriorityTableId =

                CCDGlobalBearerTypePriorizationRecord::CreateTableL( iSession );

        }

	CCmPluginBaseEng::ConstructL();

	OstTraceFunctionExit0( CCMPLUGINVPN_CONSTRUCTL_EXIT );

	}

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

// CCmPluginVpn::GetBearerInfoIntL

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

//

TUint32 CCmPluginVpn::GetBearerInfoIntL( TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERINFOINTL_ENTRY );

    TUint32 retVal( 0 );

    switch ( aAttribute )

        {

        case ECmSeamlessnessLevel:

            {

            retVal = ESeamlessnessShowprogress;

            }

            break;

        case ECmBearerType:

            {             

            retVal = iBearerType;

            }

            break;

        case ECmCommsDBBearerType:

            {                         

            retVal = KCommDbBearerVirtual;

            }

            break;

        case ECmExtensionLevel:

            {

            retVal = KExtensionBaseLevel;

            }

            break;

        case ECmDefaultUiPriority: //falls through

        case ECmDefaultPriority:

            {

            retVal = GetDefPriorityL( aAttribute );

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERINFOINTL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::GetBearerInfoBoolL

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

//

TBool CCmPluginVpn::GetBearerInfoBoolL( TUint32 aAttribute ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERINFOBOOLL_ENTRY );

    TBool retVal( EFalse );

    switch ( aAttribute )

        {

        case ECmCoverage:

            {

            //This parameter is not actually in use for the VPN.

            //ConnMon component can make a proper coverage discovery for the VPN,

            //but CmManager just returns the default value.

            retVal = EFalse;

            }

            break;

        case ECmDestination:

            {

            retVal = EFalse;

            }

            break;

        case ECmBearerHasUi:

            {                

            retVal = EFalse;

            }

            break;

        case ECmIPv6Supported:

            {            

            retVal = EFalse;

            }

            break;

        case ECmVirtual:

            {

            retVal = ETrue;

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }    

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERINFOBOOLL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::GetBearerInfoStringL

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

//

HBufC* CCmPluginVpn::GetBearerInfoStringL( TUint32 /*aAttribute*/ ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERINFOSTRINGL_ENTRY );

    User::Leave( KErrNotSupported );

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERINFOSTRINGL_EXIT );

    return NULL;

    }

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

// CCmPluginVpn::GetBearerInfoString8L

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

//

HBufC8* CCmPluginVpn::GetBearerInfoString8L( TUint32 /*aAttribute*/ ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERINFOSTRING8L_ENTRY );

    User::Leave( KErrNotSupported );

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERINFOSTRING8L_EXIT );

    return NULL;

    }

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

// CCmPluginVpn::CanHandleIapIdL

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

//

TBool CCmPluginVpn::CanHandleIapIdL( TUint32 aIapId ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_CANHANDLEIAPIDL_ENTRY );

    TBool retVal( EFalse );

    CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

                            ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

    CleanupStack::PushL( iapRecord );

    iapRecord->SetRecordId( aIapId );

    iapRecord->LoadL( iSession );

    retVal = CanHandleIapIdL( iapRecord );

    CleanupStack::PopAndDestroy( iapRecord );

    OstTraceFunctionExit0( CCMPLUGINVPN_CANHANDLEIAPIDL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::CanHandleIapIdL

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

//

TBool CCmPluginVpn::CanHandleIapIdL( CommsDat::CCDIAPRecord* aIapRecord ) const

    {

    OstTraceFunctionEntry0( DUP1_CCMPLUGINVPN_CANHANDLEIAPIDL_ENTRY );

    TBool retVal( EFalse );

    if( TPtrC(aIapRecord->iServiceType) == TPtrC(KCDTypeNameVPNService) ||

        TPtrC(aIapRecord->iBearerType) == TPtrC(KCDTypeNameVirtualBearer) )

        {

        // Further comparision is to find exact info that the IAP can handle by this plugin

        CMDBRecordSet<CCDVirtualBearerRecord>* bearersRS = 

                new(ELeave) CMDBRecordSet<CCDVirtualBearerRecord>

                                                   (KCDTIdVirtualBearerRecord);

        CleanupStack::PushL( bearersRS );

        CCDVirtualBearerRecord* bearerRecord = 

                static_cast<CCDVirtualBearerRecord *>

                    (CCDRecordBase::RecordFactoryL(KCDTIdVirtualBearerRecord));

        CleanupStack::PushL( bearerRecord );

        // Find entries used "vpnconnagt.agt" as agent from Table VirtualBearer

        bearerRecord->iBearerAgent.SetL( KVpnVirtualBearerAgent );

        bearersRS->iRecords.AppendL( bearerRecord );

        CleanupStack::Pop( bearerRecord );

        bearerRecord = NULL;

        if ( bearersRS->FindL( iSession ) )

            {

            TUint32 recordId = (*bearersRS)[0]->RecordId();

            TPtrC bearerName( (*bearersRS)[0]->iRecordName.GetL() );

            // Further comparing record ID referred to by this VPN IAP with entry ID in table VirtualBearer

            // And also comparing bear name with our expected one "vpnbearer"

            if( recordId == aIapRecord->iBearer && 

                bearerName == TPtrC( KVpnVirtualBearerName ) )

                {

                retVal = ETrue;

                }

            }        

        CleanupStack::PopAndDestroy( bearersRS );

        }

    OstTraceFunctionExit0( DUP1_CCMPLUGINVPN_CANHANDLEIAPIDL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::GetBearerTableIdsToBeObservedL

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

//

void CCmPluginVpn::GetBearerTableIdsToBeObservedL( RArray<TUint32>& aTableIdArray ) const

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERTABLEIDSTOBEOBSERVEDL_ENTRY );

    aTableIdArray.AppendL( KCDTIdVirtualBearerRecord );

    aTableIdArray.AppendL( iVirtualTableId );

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERTABLEIDSTOBEOBSERVEDL_EXIT );

    }

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

// CCmPluginVpn::GetBearerSpecificRecordsL

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

//

void CCmPluginVpn::GetBearerSpecificRecordsL(RPointerArray<CommsDat::CCDRecordBase>& aRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERSPECIFICRECORDSL_ENTRY );

    __ASSERT_DEBUG( iVirtualIapNextLayerRecord != NULL, User::Invariant() );  

    CCDVirtualIAPNextLayerRecord* virtualIapNextLayerRecordCopy = 

                new (ELeave) CCDVirtualIAPNextLayerRecord( iVirtualTableId );

    CleanupStack::PushL( virtualIapNextLayerRecordCopy );

    TUint value = iVirtualIapNextLayerRecord->iIAP;

    virtualIapNextLayerRecordCopy->iIAP = value;

    value = iVirtualIapNextLayerRecord->iNextLayerSNAP;

    virtualIapNextLayerRecordCopy->iNextLayerSNAP = value;

    value = iVirtualIapNextLayerRecord->iNextLayerIAP;

    virtualIapNextLayerRecordCopy->iNextLayerIAP = value;

    virtualIapNextLayerRecordCopy->SetElementId( iVirtualIapNextLayerRecord->ElementId() );

    User::LeaveIfError( aRecordArray.Append( virtualIapNextLayerRecordCopy ) );

    CleanupStack::Pop( virtualIapNextLayerRecordCopy );    

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERSPECIFICRECORDSL_EXIT );

    }

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

// CCmPluginVpn::GetBearerIntAttributeL

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

//

TUint32 CCmPluginVpn::GetBearerIntAttributeL( 

        TUint32 aAttribute, 

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERINTATTRIBUTEL_ENTRY );

    CCDVPNServiceRecord* serviceRecord = static_cast<CCDVPNServiceRecord *>                

                                                        ( aGenRecordArray[KServiceRecordIndex] );

    TUint32 retVal( 0 );

    switch( aAttribute )

        {

        case ECmExtensionLevel:   

            {

            retVal = KExtensionBaseLevel;

            }

            break;

        case ECmCommsDBBearerType:

            {

            TCommsDBBearerTechnology bearer = KCommDbBearerVirtual; 

            retVal = bearer;

            }

            break;

        case ECmNextLayerIapId:

        case EVpnIapId:

            {            

            TUint recordId = serviceRecord->iServiceIAP;//TODO, can't use this straight? link containd the ID.

            if (recordId != 0)

                {

                CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

                                        ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

                CleanupStack::PushL( iapRecord );

                iapRecord->SetRecordId( recordId );

                iapRecord->LoadL( iSession );

                retVal = iapRecord->RecordId();

                CleanupStack::PopAndDestroy( iapRecord );                             

                }

            }

            break;

        case EVpnNetworkId:

        case ECmNextLayerSNAPId:

            {

            TUint recordId = serviceRecord->iServiceSNAP;

            if ( recordId != 0 )

                {

                CCDAccessPointRecord* accessPointRecord = static_cast<CCDAccessPointRecord*>(

                        CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) );

                CleanupStack::PushL( accessPointRecord );

                accessPointRecord->SetRecordId( recordId );

                accessPointRecord->LoadL( iSession );

                retVal = accessPointRecord->iRecordTag;

                CleanupStack::PopAndDestroy( accessPointRecord );

                if ( aAttribute == EVpnNetworkId )

                    {

                    __ASSERT_DEBUG( retVal >= KCmmDestIdIntervalMin, User::Invariant() );//TODO, replace with iCustomSelectionPolicy

                    retVal -= KCmmDestIdIntervalMin;

                    }

                }

            }

            break;

        default:

            {

            retVal = GetBearerInfoIntL( aAttribute );

            }

            break;

        }

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERINTATTRIBUTEL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::GetBearerBoolAttributeL

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

//

TBool CCmPluginVpn::GetBearerBoolAttributeL( 

        TUint32 aAttribute, 

        RPointerArray<CommsDat::CCDRecordBase>& /*aGenRecordArray*/,

        RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERBOOLATTRIBUTEL_ENTRY );

    //We don't have IAP specific bool attributes, but the bearer specific

    //attributes may also be asked this way...

    TBool retVal = GetBearerInfoBoolL( aAttribute );              

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERBOOLATTRIBUTEL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::GetBearerStringAttributeL

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

//

HBufC* CCmPluginVpn::GetBearerStringAttributeL( 

        TUint32 aAttribute, 

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )

    {

    OstTraceFunctionEntry0( CCMPLUGINVPN_GETBEARERSTRINGATTRIBUTEL_ENTRY );

    CCDVPNServiceRecord* serviceRecord = static_cast<CCDVPNServiceRecord *>                

                                                        ( aGenRecordArray[KServiceRecordIndex] );

    HBufC* retVal =  NULL;

    switch( aAttribute )

        {

        case EVpnServicePolicy:

            {

            retVal = TPtrC( serviceRecord->iServicePolicy ).AllocL();

            }

            break;

        default:

            {

            retVal = GetBearerInfoStringL( aAttribute );

            }

            break;

        }

    OstTraceFunctionExit0( CCMPLUGINVPN_GETBEARERSTRINGATTRIBUTEL_EXIT );

    return retVal;

    }

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

// CCmPluginVpn::GetBearerString8AttributeL

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

//