/*

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

*      for Lan Bearer

*

*

*/

#include "cmpluginlan.h"

#include "datamobilitycommsdattypes.h"

#include <cmmanagerdef.h>

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

#include <featmgr.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmpluginlanTraces.h"

#endif

using namespace CMManager;

using namespace CommsDat;

_LIT( KEmpty, "" );

_LIT( KLanBearerName, "LANBearer" );

_LIT( KLanBearerAgent, "nullagt.agt" );

_LIT( KLanBearerNif, "ethint" );

_LIT( KLanLDDFileName, "enet" );

_LIT( KLanPDDFileName, "ethernet" );

_LIT( KLanLDDName, "Ethernet" );

_LIT( KLanPDDName, "Ethernet.Wins" );

_LIT( KLanPacketDriverName, "EtherPkt.drv" );

const TBool KDefIpAddrFromServer = ETrue;

const TBool KDefIpDnsAddrFromServer = ETrue;

const TBool KDefIp6DnsAddrFromServer = ETrue;

const TInt KLanLastSocketActivityTimeout = -1;

const TInt KLanLastSocketClosedTimeout = -1;

const TInt KLanLastSessionClosedTimeout = -1;

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

// CCmPluginLan::NewOutgoingL()

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

//

CCmPluginLan* CCmPluginLan::NewL( TCmPluginInitParam* aInitParam )

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_NEWL_ENTRY );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMPLUGINLAN_NEWL_EXIT );

    return self;

    }

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

// CCmPluginLan::CreateInstanceL

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

//

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

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_CREATEINSTANCEL_ENTRY );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMPLUGINLAN_CREATEINSTANCEL_EXIT );

    return self;

    }

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

// CCmPluginLan::~CCmPluginLan()

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

//

CCmPluginLan::~CCmPluginLan()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_CCMPLUGINLAN_ENTRY );

    ResetBearerRecords();

    OstTraceFunctionExit0( CCMPLUGINLAN_CCMPLUGINLAN_EXIT );

    }

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

// CCmPluginLan::CCmPluginLan()

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

//

CCmPluginLan::CCmPluginLan( TCmPluginInitParam* aInitParam )

        :

        CCmPluginBaseEng( aInitParam )

    {

    OstTraceFunctionEntry0( DUP1_CCMPLUGINLAN_CCMPLUGINLAN_ENTRY );

    iBearerType = KUidLanBearerType;

    iBearerRecord = NULL;

    OstTraceFunctionExit0( DUP1_CCMPLUGINLAN_CCMPLUGINLAN_EXIT );

    }

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

// CCmPluginLan::ConstructL()

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

//

void CCmPluginLan::ConstructL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_CONSTRUCTL_ENTRY );

    // Feature Manager is initialized by the CmmServer, so no need to do it here.

    CCmPluginBaseEng::ConstructL();

    // Get bearer priority table ID.

    TRAP_IGNORE( iBearerPriorityTableId = 

            CCDGlobalBearerTypePriorizationRecord::TableIdL( iSession ) );

    if ( !iBearerPriorityTableId )

        {

        iBearerPriorityTableId = 

                CCDGlobalBearerTypePriorizationRecord::CreateTableL( iSession );

        }

    OstTraceFunctionExit0( CCMPLUGINLAN_CONSTRUCTL_EXIT );

    }

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

// CCmPluginLan::CanHandleIapIdL()

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

//

TBool CCmPluginLan::CanHandleIapIdL( TUint32 aIapId ) const

    {

    OstTraceFunctionEntryExt( CCMPLUGINLAN_CANHANDLEIAPIDL_ENTRY, this );

    TBool retVal( EFalse );

    CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

                            ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

    CleanupStack::PushL( iapRecord );

    iapRecord->SetRecordId( aIapId );

    TRAPD( err, iapRecord->LoadL( iSession ) );

    if ( !err )

        {

        retVal = CanHandleIapIdL( iapRecord );

        }

    CleanupStack::PopAndDestroy( iapRecord );

    OstTraceFunctionExitExt( CCMPLUGINLAN_CANHANDLEIAPIDL_EXIT, this, retVal );

    return retVal;

    }

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

// CCmPluginLan::CanHandleIapIdL()

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

//

TBool CCmPluginLan::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const

    {

    OstTraceFunctionEntryExt( DUP1_CCMPLUGINLAN_CANHANDLEIAPIDL_ENTRY, this );

    TBool retVal( EFalse );

    if ( (TPtrC( aIapRecord->iServiceType ) == TPtrC( KCDTypeNameLANService ) ) &&

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

        {

        retVal = ETrue;

        }

    OstTraceFunctionExitExt( DUP1_CCMPLUGINLAN_CANHANDLEIAPIDL_EXIT, this, retVal );

    return retVal;

    }

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

// CCmPluginLan::PreparePluginToUpdateRecordsL()

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

//

void CCmPluginLan::PreparePluginToLoadRecordsL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_PREPAREPLUGINTOLOADRECORDSL_ENTRY );

    OstTraceFunctionExit0( CCMPLUGINLAN_PREPAREPLUGINTOLOADRECORDSL_EXIT );

    }

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

// CCmPluginLan::PreparePluginToUpdateRecordsL()

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

//

void CCmPluginLan::PreparePluginToUpdateRecordsL(

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

        RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_PREPAREPLUGINTOUPDATERECORDSL_ENTRY );

    CCDIAPRecord* iapRecord =

                static_cast<CCDIAPRecord*>( aGenRecordArray[KIapRecordIndex] );

    CCDLANServiceRecord* serviceRecord =

            static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

    CheckIfNameModifiedL( iapRecord, serviceRecord );

    CheckDNSServerAddressL( ETrue,

                            serviceRecord->iIp6NameServer1,

                            serviceRecord->iIp6NameServer2,

                            serviceRecord->iIp6DnsAddrFromServer );

    CheckDNSServerAddressL( EFalse,

                            serviceRecord->iIpNameServer1,

                            serviceRecord->iIpNameServer2,

                            serviceRecord->iIpDnsAddrFromServer );

    SetDaemonNameL( aGenRecordArray, aBearerSpecRecordArray );

    OstTraceFunctionExit0( CCMPLUGINLAN_PREPAREPLUGINTOUPDATERECORDSL_EXIT );

    }

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

// CCmPluginLan::CreateServiceRecordL

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

//

void CCmPluginLan::CreateServiceRecordL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_CREATESERVICERECORDL_ENTRY );

    delete iServiceRecord;

    iServiceRecord = NULL;

    iServiceRecord = static_cast<CCDLANServiceRecord*>(

            CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

    CCDLANServiceRecord* lanServiceRecord = static_cast<CCDLANServiceRecord*>( iServiceRecord );

    if ( FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )

        {

        lanServiceRecord->iIfNetworks.SetL( KDefIspIfNetworksIPv4IPv6LAN );

        }

    else

        {

        lanServiceRecord->iIfNetworks.SetL( KDefIspIfNetworksIPv4 );

        }

    lanServiceRecord->iIpGateway.SetL( KUnspecifiedIPv4 );

    lanServiceRecord->iIpAddrFromServer.SetL( KDefIpAddrFromServer );

    lanServiceRecord->iIpAddr.SetL( KUnspecifiedIPv4 );

    lanServiceRecord->iIpDnsAddrFromServer.SetL( KDefIpDnsAddrFromServer );

    lanServiceRecord->iIpNameServer1.SetL( KUnspecifiedIPv4 );

    lanServiceRecord->iIpNameServer2.SetL( KUnspecifiedIPv4 );

    lanServiceRecord->iIp6DnsAddrFromServer.SetL( KDefIp6DnsAddrFromServer );

    lanServiceRecord->iIp6NameServer1.SetL( KDynamicIpv6Address );

    lanServiceRecord->iIp6NameServer2.SetL( KDynamicIpv6Address );

    if ( KDefIpAddrFromServer )

        {

        lanServiceRecord->iConfigDaemonManagerName.SetL( KDaemonManagerName );

        lanServiceRecord->iConfigDaemonName.SetL( KConfigDaemonName );

        }

    else

        {

        lanServiceRecord->iConfigDaemonManagerName.SetL( KEmpty );

        lanServiceRecord->iConfigDaemonName.SetL( KEmpty );

        }

    OstTraceFunctionExit0( CCMPLUGINLAN_CREATESERVICERECORDL_EXIT );

    }

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

// CCmPluginLan::LoadServiceRecordL

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

//

void CCmPluginLan::LoadServiceRecordL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_LOADSERVICERECORDL_ENTRY );

    if ( TPtrC( KCDTypeNameLANService ) == iIapRecord->iServiceType )

        {

        iServiceRecord = static_cast<CCDLANServiceRecord *>(

                CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

        ServiceRecord().SetRecordId( iIapRecord->iService );

        ServiceRecord().LoadL( iSession );

        }

    else

        {

        // This IAP service is not supported by this plugin.

        User::Leave( KErrNotSupported );

        }

    OstTraceFunctionExit0( CCMPLUGINLAN_LOADSERVICERECORDL_EXIT );

    }

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

// CCmPluginLan::PrepareToCopyDataL

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

//

void CCmPluginLan::PrepareToCopyDataL( CCmPluginBaseEng* /*aCopyInstance*/ )

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_PREPARETOCOPYDATAL_ENTRY );

    OstTraceFunctionExit0( CCMPLUGINLAN_PREPARETOCOPYDATAL_EXIT );

    }

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

// CCmPluginLan::CopyServiceRecordL

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

//

CommsDat::CCDRecordBase* CCmPluginLan::CopyServiceRecordL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_COPYSERVICERECORDL_ENTRY );

    // New service record to be returned.

    CCDRecordBase* serviceRecord = static_cast<CCDLANServiceRecord*>(

            CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

    CleanupStack::PushL( serviceRecord );

    CCDLANServiceRecord* tempServiceRecordPtrToNew =

            static_cast<CCDLANServiceRecord*>( serviceRecord );

    // CommsDat version of service record.

    CCDLANServiceRecord* origServiceRecord =

            static_cast<CCDLANServiceRecord*>( iServiceRecord );

    if ( !origServiceRecord->iRecordTag.IsNull() )

        {

        tempServiceRecordPtrToNew->iRecordTag.SetL(

                origServiceRecord->iRecordTag );

        }

    if ( !origServiceRecord->iRecordName.IsNull() )

        {

        tempServiceRecordPtrToNew->iRecordName.SetL(

                origServiceRecord->iRecordName );

        }

    if ( !origServiceRecord->iServiceEnableLlmnr.IsNull() )

        {

        tempServiceRecordPtrToNew->iServiceEnableLlmnr.SetL(

                origServiceRecord->iServiceEnableLlmnr );

        }

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

        {

        tempServiceRecordPtrToNew->iIfNetworks.SetL(

                origServiceRecord->iIfNetworks );

        }

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

        {

        tempServiceRecordPtrToNew->iIpNetmask.SetL(

                origServiceRecord->iIpNetmask );

        }

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

        {

        tempServiceRecordPtrToNew->iIpGateway.SetL(

                origServiceRecord->iIpGateway );

        }

    if ( !origServiceRecord->iIpAddrFromServer.IsNull() )

        {

        tempServiceRecordPtrToNew->iIpAddrFromServer.SetL(

                origServiceRecord->iIpAddrFromServer );

        }

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

        {

        tempServiceRecordPtrToNew->iIpAddr.SetL(

                origServiceRecord->iIpAddr );

        }

    if ( !origServiceRecord->iIpDnsAddrFromServer.IsNull() )

        {

        tempServiceRecordPtrToNew->iIpDnsAddrFromServer.SetL(

                origServiceRecord->iIpDnsAddrFromServer );

        }

    if ( !origServiceRecord->iIpNameServer1.IsNull() )

        {

        tempServiceRecordPtrToNew->iIpNameServer1.SetL(

                origServiceRecord->iIpNameServer1 );

        }

    if ( !origServiceRecord->iIpNameServer2.IsNull() )

        {

        tempServiceRecordPtrToNew->iIpNameServer2.SetL(

                origServiceRecord->iIpNameServer2 );

        }

    if ( !origServiceRecord->iIp6DnsAddrFromServer.IsNull() )

        {

        tempServiceRecordPtrToNew->iIp6DnsAddrFromServer.SetL(

                origServiceRecord->iIp6DnsAddrFromServer );

        }

    if ( !origServiceRecord->iIp6NameServer1.IsNull() )

        {

        tempServiceRecordPtrToNew->iIp6NameServer1.SetL(

                origServiceRecord->iIp6NameServer1 );

        }

    if ( !origServiceRecord->iIp6NameServer2.IsNull() )

        {

        tempServiceRecordPtrToNew->iIp6NameServer2.SetL(

                origServiceRecord->iIp6NameServer2 );

        }

    if ( !origServiceRecord->iIpAddrLeaseValidFrom.IsNull() )

        {

        tempServiceRecordPtrToNew->iIpAddrLeaseValidFrom.SetL(

                origServiceRecord->iIpAddrLeaseValidFrom );

        }

    if ( !origServiceRecord->iIpAddrLeaseValidTo.IsNull() )

        {

        tempServiceRecordPtrToNew->iIpAddrLeaseValidTo.SetL(

                origServiceRecord->iIpAddrLeaseValidTo );

        }

    if ( !origServiceRecord->iConfigDaemonManagerName.IsNull() )

        {

        tempServiceRecordPtrToNew->iConfigDaemonManagerName.SetL(

                origServiceRecord->iConfigDaemonManagerName );

        }

    if ( !origServiceRecord->iConfigDaemonName.IsNull() )

        {

        tempServiceRecordPtrToNew->iConfigDaemonName.SetL(

                origServiceRecord->iConfigDaemonName );

        }

    if ( !origServiceRecord->iServiceExtensionTableName.IsNull() )

        {

        tempServiceRecordPtrToNew->iServiceExtensionTableName.SetL(

                origServiceRecord->iServiceExtensionTableName );

        }

    if ( !origServiceRecord->iServiceExtensionTableRecordId.IsNull() )

        {

        tempServiceRecordPtrToNew->iServiceExtensionTableRecordId.SetL(

                origServiceRecord->iServiceExtensionTableRecordId );

        }

    CleanupStack::Pop( serviceRecord );

    OstTraceFunctionExit0( CCMPLUGINLAN_COPYSERVICERECORDL_EXIT );

    return serviceRecord;

    }

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

// CCmPluginLan::UpdateServiceRecordL()

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

//

void CCmPluginLan::UpdateServiceRecordL(

        RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

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

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_UPDATESERVICERECORDL_ENTRY );

    // Delete the original record and create a copy from the client's copy.

    delete iServiceRecord;

    iServiceRecord = NULL;

    iServiceRecord = static_cast<CCDLANServiceRecord*>(

            CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

    CCDLANServiceRecord* origServiceRecord = static_cast<CCDLANServiceRecord*>( iServiceRecord );

    // Client's copy of lan service record.

    CCDLANServiceRecord* clientServiceRecordCopy =

            static_cast<CCDLANServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );

    origServiceRecord->SetElementId( clientServiceRecordCopy->ElementId() );

    if ( !origServiceRecord->RecordId() )

        {

        origServiceRecord->SetRecordId( KCDNewRecordRequest );

        origServiceRecord->StoreL( iSession );

        // Update received element ID to client's copy too.

        clientServiceRecordCopy->SetElementId( origServiceRecord->ElementId() );

        }

    else

        {

        origServiceRecord->ModifyL( iSession );

        }

    OstTraceFunctionExit0( CCMPLUGINLAN_UPDATESERVICERECORDL_EXIT );

    }

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

// CCmPluginLan::CreateBearerRecordsL

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

//

void CCmPluginLan::CreateBearerRecordsL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_CREATEBEARERRECORDSL_ENTRY );

    OstTraceFunctionExit0( CCMPLUGINLAN_CREATEBEARERRECORDSL_EXIT );