/*

* Copyright (c) 2006 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:  VPN plug-in IF implementation class.

*

*/

#include <AknsUtils.h>

#include <cmpluginvpn.mbg>

#include <cmpluginvpnui.rsg>

#include <cmmanager.rsg>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include <cmcommonui.h>

#include <aknPopup.h>

#include <aknlistquerydialog.h>

#include <AknIconArray.h>

#include <vpnapidefs.h>

#include <cmpluginwlandef.h>

// #include <vpnapi.h>

#include <centralrepository.h>

#include <SettingsInternalCRKeys.h>

#include <featmgr.h>

#include <ConeResLoader.h>

#include <bautils.h>

#include "cmlogger.h"

#include "cmmanagerimpl.h"

#include "cmdestinationimpl.h"

#include "cmvpncommonconstants.h"

#include <cmcommonconstants.h>

#include "cmpluginvpn.h"

#include "cmpvpnsettingsdlg.h"

#include "cmpvpnpolicyselectiondlg.h"

#include "cmpvpnnextlayerselectdlg.h"

using namespace CMManager;

_LIT( KPluginVpnFileIcons, "z:cmpluginvpn.mbm" );

//_LIT(KListItemFormat, "%d\t%S\t%S");

static const TCmAttribConvTable SVpnConvTbl[] = 

    {

        { EVpnServicePolicyName, EPluginVpnAttribRangeMax, NULL },

        { EVpnServicePolicy, KCDTIdVPNPolicyName, NULL,

          R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE,

          0, EConvCompulsory, R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE_COMPULSORY, 0, NULL, NULL },

        { EVpnServicePolicyName, 0, NULL,

          R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE,

          0, EConvCompulsory, R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE_COMPULSORY, 0, NULL, NULL },

        { EVpnIapId, KCDTIdVPNIAPRecord, NULL },

        { EVpnNetworkId, KCDTIdVPNNetwork, &ReadOnlyAttributeL },

        { 0, 0, NULL }

    };

static const TCmAttribConvTable SVpnVirtualIAPNextLayerConvTbl[] = 

    {

        { ECmNextLayerIapId, ECmNextLayerSNAPId+1, NULL },

        { ECmNextLayerIapId, KCDTIdVirtualNextLayerIAP, NULL },

        { ECmNextLayerSNAPId, KCDTIdVirtualNextLayerSNAP, NULL },

        { 0, 0, NULL }

    };

_LIT( KVpnVirtualBearerName, "vpnbearer" );

_LIT( KVpnVirtualBearerAgent, "vpnconnagt.agt" );

_LIT( KVpnVirtualBearerNif, "tunnelnif" );

// constants needed for the virtualbearer table

const TInt KNoTimeout = -1;

const TUint32 KLastSessionTimeout = 3;

const TUint32 KContainsVpn =        0x01;

const TUint32 KLinksBackToParent =  0x02;

const TUint32 KEmptyDest =          0x04;

const TUint32 KNoNonVirtuals =      0x08;

const TUint32 KBindDenied = KLinksBackToParent | KContainsVpn;

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

// CCmPluginVpn::NewL()

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

//

CCmPluginVpn* CCmPluginVpn::NewL( TCmPluginInitParam* aInitParam )

    {

    CRepository* repository = CRepository::NewLC(KCRUidCommunicationSettings);

    TInt vpnSupported;

    repository->Get(KSettingsVPNSupported, vpnSupported);

    CleanupStack::PopAndDestroy(repository);

    if( !vpnSupported )

        {

        User::Leave( KErrNotSupported );

        }

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmPluginVpn::~CCmPluginVpn()

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

//

CCmPluginVpn::~CCmPluginVpn()

    {

    CCmPluginVpn::AdditionalReset();

    RemoveResourceFile( KPluginVPNResDirAndFileName );

    iBindableMethods.Reset();

    iBindableMethods.Close();

    delete iPolicyName;

    CLOG_CLOSE;

    }

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

// CCmPluginVpn::CreateInstanceL

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

//

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

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmPluginVpn::CCmPluginVpn()

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

//

CCmPluginVpn::CCmPluginVpn( TCmPluginInitParam* aInitParam )

    : CCmPluginBaseEng( aInitParam )

    , iBindableMethods( KCmArraySmallGranularity )

    {

    CLOG_CREATE;

    iBearerType = KPluginVPNBearerTypeUid;

    }

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

// CCmPluginVpn::ConstructL()

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

//

void CCmPluginVpn::ConstructL()

    {

    CCmPluginBaseEng::ConstructL();

    TRAP_IGNORE( iVirtualTableId = 

                        CCDVirtualIAPNextLayerRecord::TableIdL( Session() ) );

    if( !iVirtualTableId )

        {

        iVirtualTableId = CCDVirtualIAPNextLayerRecord::CreateTableL( Session() );

        }

    AddResourceFileL( KPluginVPNResDirAndFileName );

    AddConverstionTableL( (CCDRecordBase**)&iServiceRecord, NULL, SVpnConvTbl );

    iPolicyName = KNullDesC().AllocL();

    }

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

// CCmPluginVpn::GetIntAttributeL()

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

//

TUint32 CCmPluginVpn::GetIntAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginVpn::GetIntAttributeL" );

    TUint32 retVal( 0 );

    switch( aAttribute )

        {

        case ECmBearerIcon:

            {

            TAknsItemID id;

            MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

            TParse mbmFile;

            User::LeaveIfError( mbmFile.Set( KPluginVpnFileIcons, 

                                             &KDC_BITMAP_DIR, 

                                             NULL ) );

            retVal = (TUint32)AknsUtils::CreateGulIconL( 

                                    skinInstance, 

                                    id,

                                    mbmFile.FullName(), 

                                    EMbmCmpluginvpnQgn_prop_vpn_access_point, 

                                    EMbmCmpluginvpnQgn_prop_vpn_access_point_mask );

            }

            break;

        case ECmCommsDBBearerType:

            {

            retVal = KCommDbBearerVirtual;

            }

            break;

        case ECmDefaultUiPriority:

        case ECmDefaultPriority:            

            {

            retVal = aAttribute == ECmDefaultPriority ?

                        GlobalBearerPriority( TPtrC(KCDTypeNameVPNService) ) :

                        GlobalUiBearerPriority( TPtrC(KCDTypeNameVPNService) );

            }

            break;  

        case EVpnIapId:

            {

            if( !ServiceRecordExists() )

                {

                User::Leave( KErrNotSupported );

                }

            retVal = ServiceRecord().iServiceIAP;

            }

            break;

        case EVpnNetworkId:

            {

            if( !ServiceRecordExists() )

                {

                User::Leave( KErrNotSupported );

                }

            retVal = ServiceRecord().iServiceNetwork;

            }

            break;

        case ECmNextLayerIapId:    

            {

            retVal = iVirtualRecord->iNextLayerIAP;

            }  

            break;

        case ECmNextLayerSNAPId:           

            {

            retVal = iVirtualRecord->iNextLayerSNAP;

            }  

            break;

        case ECmIapId:

        case ECmId:

        case ECmWapId:

        case ECmIapServiceId:

        case ECmInvalidAttribute:

        case ECmLoadResult:

        case ECmBearerType:

        case ECmSeamlessnessLevel:

        case ECmElementID:

        case ECmNetworkId:

        case ECmProxyPortNumber:

        case ECmExtensionLevel:

        case ECmWapIPWSPOption:

        case ECmWapIPProxyPort:

        case ECmNamingMethod:

            {

            retVal = CCmPluginBaseEng::GetIntAttributeL( aAttribute );

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

        }

    return retVal;

    }

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

// CCmPluginVpn::GetBoolAttributeL()

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

//

TBool CCmPluginVpn::GetBoolAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginVpn::GetBoolAttributeL" );

    TBool retVal( EFalse );

    switch( aAttribute )

        {

        case ECmAddToAvailableList:

            {

            retVal = EFalse;

            }

            break;

        case ECmChargeCardUsageEnabled:

            {

            retVal = EFalse;

            }

            break;

        case ECmBearerHasUi:

            {

            retVal = ETrue;

            break;

            }

        case ECmCoverage:

        case ECmDestination:

        case ECmIPv6Supported:

        case ECmHidden:

        case ECmProtected:

        case ECmMetaHighlight:

        case ECmMetaHiddenAgent:

        case ECmProxyUsageEnabled:

        case ECmConnected:

        case ECmIsLinked:

        case ECmWapIPSecurity:

            {

            retVal = CCmPluginBaseEng::GetBoolAttributeL( aAttribute );

            }

            break;

        case ECmVirtual:

            {

            return ETrue;

            }           

        default:

            {

            User::Leave( KErrNotSupported );

            }

        }

    return retVal;

    }

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

// CCmPluginVpn::GetStringAttributeL()

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

//

HBufC* CCmPluginVpn::GetStringAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginVpn::GetStringAttributeL" );

    HBufC* retVal = NULL;

    switch( aAttribute )

        {           

        case ECmBearerSupportedName:

            {

            retVal = AllocReadL( R_QTN_NETW_CONSET_BEARER_SUPPORTED_VPN );

            }

            break;

        case EVpnServicePolicyName:

            {

            if( !ServiceRecordExists() )

                {

                User::Leave( KErrNotSupported );

                }

            else 

                {

                CCmPluginVpn* tmp = const_cast< CCmPluginVpn * >( this );

                tmp->UpdatePolicyNameL();

                }

            retVal = iPolicyName->AllocL();

            break;

            }

        case EVpnServicePolicy:

            {

            if( !ServiceRecordExists() )

                {

                User::Leave( KErrNotSupported );

                }

            if( !ServiceRecord().iServicePolicy.IsNull() )

                {

                retVal = ServiceRecord().iServicePolicy.GetL().AllocL();

                } 

            else

                {

                retVal = KNullDesC().AllocL();

                }

            }

            break;

        case ECmName:   

        case ECmProxyServerName:

        case ECmProxyProtocolName:

        case ECmProxyExceptions:

        case ECmWapIPGatewayAddress:

        case ECmWapIPProxyLoginName:

        case ECmWapIPProxyLoginPass:

        case ECmStartPage:

            {

            retVal = CCmPluginBaseEng::GetStringAttributeL( aAttribute );

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    return retVal;

    }

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

// CCmPluginVpn::GetString8AttributeL()

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

//

HBufC8* CCmPluginVpn::GetString8AttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginVpn::GetString8AttributeL" );

    HBufC8* retVal = NULL;

    switch( aAttribute )

        {

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    return retVal;

    }

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

// CCmPluginVpn::SetIntAttributeL()

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

//

void CCmPluginVpn::SetIntAttributeL( const TUint32 aAttribute, 

                                            TUint32 aValue )

    {

    LOGGER_ENTERFN( "CCmPluginVpn::SetIntAttributeL" );

    switch( aAttribute )

        {

        case ECmNextLayerIapId: 

        case EVpnIapId:

            {

            CheckRecordIdValidityL( this, EVpnIapId, &aValue );

            // ServiceRecord.iServiceIAP should be 0 according to 

            // DM CommsDat Contents v1.4, but for now it is made

            // backward compatible

            if( !ServiceRecordExists() )

                {

                User::Leave( KErrNotSupported );

                }

            ServiceRecord().iServiceIAP = aValue;

            ServiceRecord().iServiceNetwork = 0;

            iVirtualRecord->iNextLayerIAP = aValue;

            iVirtualRecord->iNextLayerSNAP = 0;            

            }

            break;

        case EVpnNetworkId:

        case ECmNextLayerSNAPId:

            {

            // To keep backwards compability, keep these 2 attributes

            // (EVpnNetworkId & ECmNextLayerSNAPId) together even though

            // network id and destination id are no longer exactly the same.

            if( !ServiceRecordExists() )

                {

                User::Leave( KErrNotSupported );

                }

            TInt destinationId( 0 );

            destinationId = CheckValidityAndConvertDestinationIdL( aValue );

            ServiceRecord().iServiceIAP = 0;          

            ServiceRecord().iServiceNetwork = destinationId - KCmDefaultDestinationAPTagId;

            iVirtualRecord->iNextLayerIAP = 0;

            iVirtualRecord->iNextLayerSNAP = destinationId;       

            }

            break;

        case ECmSeamlessnessLevel:

        case ECmProxyPortNumber:

        case ECmNamingMethod:

        case ECmWapIPWSPOption:

        case ECmWapIPProxyPort:

            {

            CCmPluginBaseEng::SetIntAttributeL( aAttribute, aValue );

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    }

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

// CCmPluginVpn::SetBoolAttributeL()

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

//

void CCmPluginVpn::SetBoolAttributeL( const TUint32 aAttribute, 

                                      TBool aValue )

    {

    LOGGER_ENTERFN( "CCmPluginVpn::SetBoolAttributeL" );

    switch( aAttribute )

        {

        case ECmChargeCardUsageEnabled:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        case ECmHidden:

        case ECmProtected: