/*

* 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;

const TUint32 KDefaultPriorityLAN = 0;

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

// 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();

    FeatureManager::UnInitializeLib();

    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 );

    FeatureManager::InitializeLibL();

    CCmPluginBaseEng::ConstructL();

    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 );

    __ASSERT_DEBUG( iServiceRecord != NULL, User::Leave( KErrNotFound ));

    CCDRecordBase* serviceRecord = static_cast<CCDLANServiceRecord*>

                                  ( CCDRecordBase::CreateCopyRecordL( *iServiceRecord ) );

    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 parameter

    delete iServiceRecord;

    iServiceRecord = NULL;

    iServiceRecord = static_cast<CCDLANServiceRecord*>

                    (CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );

    // LAN Service copy does not work so we have to copy it manually

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

    CCDLANServiceRecord* lanServiceRecordFrom =

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

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

        {

        lanServiceRecordTo->iRecordName.SetL( lanServiceRecordFrom->iRecordName );

        }

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

        {

        lanServiceRecordTo->iIfNetworks.SetL( lanServiceRecordFrom->iIfNetworks );

        }

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

        {

        lanServiceRecordTo->iIpNetmask.SetL( lanServiceRecordFrom->iIpNetmask );

        }

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

        {

        lanServiceRecordTo->iIpGateway.SetL( lanServiceRecordFrom->iIpGateway );

        }

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

        {

        lanServiceRecordTo->iIpAddrFromServer.SetL( lanServiceRecordFrom->iIpAddrFromServer );

        }

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

        {

        lanServiceRecordTo->iIpAddr.SetL( lanServiceRecordFrom->iIpAddr );

        }

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

        {

        lanServiceRecordTo->iIpDnsAddrFromServer.SetL( lanServiceRecordFrom->iIpDnsAddrFromServer );

        }

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

        {

        lanServiceRecordTo->iIpNameServer1.SetL( lanServiceRecordFrom->iIpNameServer1 );

        }

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

        {

        lanServiceRecordTo->iIpNameServer2.SetL( lanServiceRecordFrom->iIpNameServer2 );

        }

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

        {

        lanServiceRecordTo->iIp6DnsAddrFromServer.SetL( lanServiceRecordFrom->iIp6DnsAddrFromServer );

        }

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

        {

        lanServiceRecordTo->iIp6NameServer1.SetL( lanServiceRecordFrom->iIp6NameServer1 );

        }

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

        {

        lanServiceRecordTo->iIp6NameServer2.SetL( lanServiceRecordFrom->iIp6NameServer2 );

        }

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

        {

        lanServiceRecordTo->iIpAddrLeaseValidFrom.SetL( lanServiceRecordFrom->iIpAddrLeaseValidFrom );

        }

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

        {

        lanServiceRecordTo->iIpAddrLeaseValidTo.SetL( lanServiceRecordFrom->iIpAddrLeaseValidTo );

        }

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

        {

        lanServiceRecordTo->iConfigDaemonManagerName.SetL( lanServiceRecordFrom->iConfigDaemonManagerName );

        }

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

        {

        lanServiceRecordTo->iConfigDaemonName.SetL( lanServiceRecordFrom->iConfigDaemonName );

        }

    lanServiceRecordTo->SetElementId( lanServiceRecordFrom->ElementId() );

    if ( !ServiceRecord().RecordId() )

        {

        ServiceRecord().SetRecordId( KCDNewRecordRequest );

        ServiceRecord().StoreL( iSession );

        // Update needed values to record tables too( lanservice and wlanservice )

        lanServiceRecordFrom->SetElementId( ServiceRecord().ElementId() );

        }

    else

        {

        ServiceRecord().ModifyL( iSession );

        }

    OstTraceFunctionExit0( CCMPLUGINLAN_UPDATESERVICERECORDL_EXIT );

    }

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

// CCmPluginLan::CreateBearerRecordsL

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

//

void CCmPluginLan::CreateBearerRecordsL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_CREATEBEARERRECORDSL_ENTRY );

    OstTraceFunctionExit0( CCMPLUGINLAN_CREATEBEARERRECORDSL_EXIT );

    }

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

// CCmPluginLan::LoadBearerRecordsL

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

//

void CCmPluginLan::LoadBearerRecordsL()

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_LOADBEARERRECORDSL_ENTRY );

    OstTraceFunctionExit0( CCMPLUGINLAN_LOADBEARERRECORDSL_EXIT );

    }

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

// CCmPluginLan::ServiceRecord()

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

//

CCDLANServiceRecord& CCmPluginLan::ServiceRecord() const

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_SERVICERECORD_ENTRY );

    return *static_cast<CCDLANServiceRecord*>( iServiceRecord );

    }

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

// CCmPluginLan::ServiceRecordIdLC

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

//

TUint32 CCmPluginLan::ServiceRecordId() const

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_SERVICERECORDID_ENTRY );

    return ServiceRecord().RecordId();

    }

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

// CCmPluginLan::ServiceRecordNameLC

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

//

void CCmPluginLan::ServiceRecordNameLC( HBufC* &aName )

    {

    OstTraceFunctionEntry0( CCMPLUGINLAN_SERVICERECORDNAMELC_ENTRY );

    aName = TPtrC( KCDTypeNameLANService ).AllocLC();

    OstTraceFunctionExit0( CCMPLUGINLAN_SERVICERECORDNAMELC_EXIT );

    }

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

// CCmPluginLan::BearerRecordIdL()

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

//

void CCmPluginLan::BearerRecordIdL( TUint32& aRecordId )

    {

    CCDLANBearerRecord* lanBearerRecord = static_cast<CCDLANBearerRecord*>

                        (CCDRecordBase::RecordFactoryL( KCDTIdLANBearerRecord ));

    CleanupStack::PushL( lanBearerRecord );

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

    if ( !lanBearerRecord->FindL( iSession ) )

        { // bearer not found -> create dummy values

        lanBearerRecord->SetRecordId( KCDNewRecordRequest );

        lanBearerRecord->iBearerAgent = KLanBearerAgent;

        lanBearerRecord->iRecordName = KLanBearerName;

        lanBearerRecord->iLanBearerNifName = KLanBearerNif;

        lanBearerRecord->iLanBearerLddFilename = KLanLDDFileName;

        lanBearerRecord->iLanBearerLddName = KLanLDDName;

        lanBearerRecord->iLanBearerPddFilename = KLanPDDFileName;

        lanBearerRecord->iLanBearerPddName = KLanPDDName;

        lanBearerRecord->iLanBearerPacketDriverName = KLanPacketDriverName;

        lanBearerRecord->iLastSocketActivityTimeout =