/*

* 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 WLAN Plugin interface implementation

*        for WLAN Bearer

*

*/

#include <ecom/ecom.h>      // For REComSession

#include <wlancontainer.h>

#include <wlanmgmtcommon.h>

#include <cmpluginwlandef.h>

#include <cmcommonconstants.h>

#include <featmgr.h>

#include "cmpluginwlan.h"

#include "cmwlancoveragecheck.h"

#include "cmmanagerdef.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmpluginwlanTraces.h"

#endif

using namespace CMManager;

enum TWlanWepKeyFormat

    {

    EWlanWepKeyFormatAscii = 0,

    EWlanWepKeyFormatHex

    };

// default values for fields...

// CONSTANTS

_LIT( KEmpty, "");

const TBool KDefIpAddrFromServer = ETrue;

const TBool KDefIpDnsAddrFromServer = ETrue;

const TBool KDefIp6DnsAddrFromServer = ETrue;

const TInt KWlanServiceRecordIndex = 0;

const TUint32 KDefaultPriorityWLan = 0;

const TInt KWlanLastSocketActivityTimeout = -1;

const TInt KWlanLastSessionClosedTimeout = 1;

const TInt KWlanLastSocketClosedTimeout = -1;

/// Modem bearer names for WLAN connection methods

_LIT( KModemBearerWLAN, "WLANBearer" );

_LIT( KWlanBearerName, "WLANBearer" );

_LIT( KWlanBearerAgent, "wlanagt.agt" );

_LIT( KWlanBearerNif, "wlannif" );

_LIT( KWlanLDDName, "not used" );

_LIT( KWlanPDDName, "not used" );

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

// CCmPluginWlan::NewL

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

//

CCmPluginWlan* CCmPluginWlan::NewL( TCmPluginInitParam* aInitParam )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_NEWL_ENTRY );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMPLUGINWLAN_NEWL_EXIT );

    return self;

    }

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

// CCmPluginWlan::~CCmPluginWlan

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

//

CCmPluginWlan::~CCmPluginWlan()

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_CCMPLUGINWLAN_ENTRY );

    ResetBearerRecords();

    FeatureManager::UnInitializeLib();

    OstTraceFunctionExit0( CCMPLUGINWLAN_CCMPLUGINWLAN_EXIT );

    }

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

// CCmPluginWlan::CreateInstanceL

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

//

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

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_CREATEINSTANCEL_ENTRY );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMPLUGINWLAN_CREATEINSTANCEL_EXIT );

    return self;

    }

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

// CCmPluginWlan::CCmPluginWlan

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

//

CCmPluginWlan::CCmPluginWlan( TCmPluginInitParam* aInitParam )

        :

        CCmPluginBaseEng( aInitParam )

    {

    OstTraceFunctionEntry0( DUP1_CCMPLUGINWLAN_CCMPLUGINWLAN_ENTRY );

    iBearerType = KUidWlanBearerType;

    iWlanServiceRecord = NULL;

    iWlanTableId = 0;

    iWAPISupported = EFalse;

    OstTraceFunctionExit0( DUP1_CCMPLUGINWLAN_CCMPLUGINWLAN_EXIT );

    }

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

// CCmPluginWlan::ConstructL

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

//

void CCmPluginWlan::ConstructL()

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_CONSTRUCTL_ENTRY );

    FeatureManager::InitializeLibL();

    if ( ! FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ) )

        {

        FeatureManager::UnInitializeLib();

        User::Leave( KErrNotSupported );

        }

    CCmPluginBaseEng::ConstructL();

    // get WLAN table id

    TRAP_IGNORE( iWlanTableId = CCDWlanServiceRecord::TableIdL( iSession ) );

    if ( !iWlanTableId )

        {

        iWlanTableId = CCDWlanServiceRecord::CreateTableL( iSession );

        TMDBElementId tableId = 0;

        TRAP_IGNORE( tableId = CCDWlanDeviceSettingsRecord::TableIdL( iSession ) );

        if ( !tableId )

            {

            CCDWlanDeviceSettingsRecord::CreateTableL( iSession );

            }

        TRAP_IGNORE( tableId = CCDWLANSecSSIDTable::TableIdL( iSession ) );

        if ( !tableId )

            {

            CCDWLANSecSSIDTable::CreateTableL( iSession );

            }

        TRAP_IGNORE( tableId = CCDDestNWTable::TableIdL( iSession ) );

        if ( !tableId )

            {

            CCDDestNWTable::CreateTableL( iSession );

            }

        }

    iWAPISupported = FeatureManager::FeatureSupported( KFeatureIdFfWlanWapi );

    OstTraceFunctionExit0( CCMPLUGINWLAN_CONSTRUCTL_EXIT );

    }

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

// CCmPluginWlan::ServiceRecord()

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

//

CCDLANServiceRecord& CCmPluginWlan::ServiceRecord() const

    {

    return *static_cast<CCDLANServiceRecord*>( iServiceRecord );

    }

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

// CCmPluginWlan::ServiceRecordId

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

//

TUint32 CCmPluginWlan::ServiceRecordId() const

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_SERVICERECORDID_ENTRY );

    return ServiceRecord().RecordId();

    }

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

// CCmPluginWlan::ServiceRecordIdLC

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

//

void CCmPluginWlan::ServiceRecordNameLC( HBufC* &aName )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_SERVICERECORDNAMELC_ENTRY );

    aName = TPtrC( KCDTypeNameLANService ).AllocLC();

    OstTraceFunctionExit0( CCMPLUGINWLAN_SERVICERECORDNAMELC_EXIT );

    }

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

// CCmPluginWlan::BearerRecordIdL()

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

//

void CCmPluginWlan::BearerRecordIdL( TUint32& aRecordId )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_BEARERRECORDIDL_ENTRY );

    CCDLANBearerRecord* lanBearerRecord = static_cast<CCDLANBearerRecord*>

                        (CCDRecordBase::RecordFactoryL( KCDTIdLANBearerRecord ));

    CleanupStack::PushL( lanBearerRecord );

    lanBearerRecord->iRecordName.SetL( TPtrC( KModemBearerWLAN ) );

    if ( !lanBearerRecord->FindL( iSession ) )

        { // bearer not found -> create dummy values

        lanBearerRecord->SetRecordId( KCDNewRecordRequest );

        lanBearerRecord->iBearerAgent = KWlanBearerAgent;

        lanBearerRecord->iRecordName = KWlanBearerName;

        lanBearerRecord->iLanBearerNifName = KWlanBearerNif;

        lanBearerRecord->iLanBearerLddName = KWlanLDDName;

        lanBearerRecord->iLanBearerPddName = KWlanPDDName;

        lanBearerRecord->iLastSocketActivityTimeout =

                                        (TUint32)KWlanLastSocketActivityTimeout;

        lanBearerRecord->iLastSessionClosedTimeout =

                                        (TUint32)KWlanLastSessionClosedTimeout;

        lanBearerRecord->iLastSocketClosedTimeout =

                                        (TUint32)KWlanLastSocketClosedTimeout;

        lanBearerRecord->StoreL( iSession );

        }

    aRecordId = lanBearerRecord->RecordId();

    CleanupStack::PopAndDestroy( lanBearerRecord );

    OstTraceFunctionExit0( CCMPLUGINWLAN_BEARERRECORDIDL_EXIT );

    }

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

// CCmPluginWlan::BearerRecordNameLC()

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

//

void CCmPluginWlan::BearerRecordNameLC( HBufC* &aBearerName )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_BEARERRECORDNAMELC_ENTRY );

    aBearerName = TPtrC( KCDTypeNameLANBearer ).AllocLC();

    OstTraceFunctionExit0( CCMPLUGINWLAN_BEARERRECORDNAMELC_EXIT );

    }

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

// CCmPluginWlan::GetBearerIntAttributeL

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

//

TUint32 CCmPluginWlan::GetBearerIntAttributeL(

        TUint32 aAttribute,

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERINTATTRIBUTEL_ENTRY );

    TUint32 retVal( 0 );

    CCDLANServiceRecord* serviceRecord =

            static_cast<CCDLANServiceRecord*>(

                    aGenRecordArray[KServiceRecordIndex] );

    CCDWlanServiceRecord* wlanServiceRecord =

            static_cast<CCDWlanServiceRecord*>(

                    aBearerSpecRecordArray[KWlanServiceRecordIndex] );

    switch ( aAttribute )

        {

        case ECmInvalidAttribute:

            {

            retVal = 0;

            }

            break;

        case ECmExtensionLevel:

            {

            // This is extension from LAN plugin

            retVal = KExtensionBaseLevel + 1;

            }

            break;

        case ECmCommsDBBearerType:

            {

            retVal = KCommDbBearerWLAN;

            }

            break;

        case ECmDefaultUiPriority:

            {

            retVal = KDefaultPriorityWLan;

            }

            break;

        case ECmDefaultPriority:

            {

            retVal = KDefaultPriorityWLan;

            }

            break;

        case EWlanServiceId:

            {

            retVal = wlanServiceRecord->iWlanServiceId;

            }

            break;

        case EWlanConnectionMode:

            {

            retVal = wlanServiceRecord->iWlanConnMode;

            }

            break;

        case EWlanSecurityMode:

            {

            retVal = wlanServiceRecord->iWlanSecMode;

            }

            break;

        case EWlanAuthenticationMode:

            {

            retVal = wlanServiceRecord->iWlanAuthMode;

            }

            break;

        case EWlanChannelID:

            {

            retVal = wlanServiceRecord->iWlanChannelID;

            }

            break;

        case EWlanServiceExtensionTableRecordId:

            {

            retVal = serviceRecord->iServiceExtensionTableRecordId;

            }

            break;

        case EWlanWepKeyIndex:

            {

            retVal = wlanServiceRecord->iWlanWepIndex;

            }

            break;

        case EWlanWapiPskFormat:

            {

            retVal = wlanServiceRecord->iWlanFormatKey1;

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    OstTraceFunctionExit0( CCMPLUGINWLAN_GETBEARERINTATTRIBUTEL_EXIT );

    return retVal;

    }

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

// CCmPluginWlan::GetBearerBoolAttributeL

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

//

TBool CCmPluginWlan::GetBearerBoolAttributeL(

        TUint32 aAttribute,

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERBOOLATTRIBUTEL_ENTRY );

    TBool retVal( EFalse );

    CCDWlanServiceRecord* wlanServiceRecord =

            static_cast<CCDWlanServiceRecord*>(

                    aBearerSpecRecordArray[KWlanServiceRecordIndex] );

    CCDLANServiceRecord* serviceRecord =

            static_cast<CCDLANServiceRecord*>(

                    aGenRecordArray[KServiceRecordIndex] );

    switch ( aAttribute )

        {

        case ECmCoverage:

            {

#ifndef __WINS__

            retVal = CheckNetworkCoverageL();

#else

            retVal = ETrue;

#endif

            }

            break;

        case ECmDestination:

            {

            retVal = EFalse;

            }

            break;

        case ECmBearerHasUi:

            {

            retVal = ETrue;

            }

            break;

        case ECmIPv6Supported:

            {

            retVal = FeatureManager::FeatureSupported( KFeatureIdIPv6 );

            }

            break;

        case EWlanScanSSID:

            {

            retVal = wlanServiceRecord->iWlanScanSSID;

            }

            break;

        case EWlanAllowSSIDRoaming:

            {

            retVal = wlanServiceRecord->iWlanAllowSSIDRoaming;

            }

            break;

        case ECmIPAddFromServer:

        case EWlanIpAddrFromServer:

            {

            retVal = serviceRecord->iIpAddrFromServer;

            }

            break;

        case ECmIPDNSAddrFromServer:

        case EWlanIpDNSAddrFromServer:

            {

            retVal = serviceRecord->iIpDnsAddrFromServer;

            }

            break;

        case ECmIP6DNSAddrFromServer:

        case EWlanIp6DNSAddrFromServer:

            {

            retVal = serviceRecord->iIp6DnsAddrFromServer;

            }

            break;

        case EWlanEnableWpaPsk:

            {

            retVal = static_cast<TBool>( wlanServiceRecord->iWlanEnableWpaPsk );

            }

            break;

        case EWlan802_1xAllowUnencrypted:

            {

            retVal = static_cast<TBool>( wlanServiceRecord->iWlanWpaKeyLength );

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    OstTraceFunctionExit0( CCMPLUGINWLAN_GETBEARERBOOLATTRIBUTEL_EXIT );

    return retVal;

    }

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

// CCmPluginWlan::GetBearerStringAttributeL

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

//

HBufC* CCmPluginWlan::GetBearerStringAttributeL(

        TUint32 aAttribute,

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERSTRINGATTRIBUTEL_ENTRY );

    HBufC* retVal = NULL;

    CCDWlanServiceRecord* wlanServiceRecord =

            static_cast<CCDWlanServiceRecord*>(

                    aBearerSpecRecordArray[KWlanServiceRecordIndex] );

    CCDLANServiceRecord* serviceRecord =

            static_cast<CCDLANServiceRecord*>(

                    aGenRecordArray[KServiceRecordIndex] );

    switch ( aAttribute )

        {

        case ECmIFNetworks:

        case EWlanIfNetworks:

            {

            if ( !serviceRecord->iIfNetworks.IsNull() )

                {

                retVal = ( serviceRecord->iIfNetworks.GetL() ).AllocL();

                }

            }

            break;

        case ECmIPNetmask:

        case EWlanIpNetMask:

            {

            if ( !serviceRecord->iIpNetmask.IsNull() )

                {

                retVal = ( serviceRecord->iIpNetmask.GetL() ).AllocL();

                }

            }

            break;

        case ECmIPGateway:

        case EWlanIpGateway:

            {

            if ( !serviceRecord->iIpGateway.IsNull() )

                {

                retVal = ( serviceRecord->iIpGateway.GetL() ).AllocL();

                }

            }

            break;

        case ECmIPAddress:

        case EWlanIpAddr:

            {

            if ( !serviceRecord->iIpAddr.IsNull() )

                {

                retVal = ( serviceRecord->iIpAddr.GetL() ).AllocL();

                }

            }

            break;