/*
* 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:  Implementation of base for Lan Plugin interface 
*                for Lan Bearer.
*
*/
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <commsdat_partner.h>
#endif
#include <cmpluginlanbase.h>
#include "cmlogger.h"
#include <ecom/ecom.h>        // For REComSession
#include <mcmdexec.h>
#include <cmpbasesettingsdlg.h>
#include "cmmanagerimpl.h"
#include <cmmanager.rsg>
#include <cmpsettingsconsts.h>

using namespace CMManager;
using namespace CommsDat;

// default values for fields...
// CONSTANTS
_LIT( KEmpty, "");

_LIT( KLanBearerName, "LANBearer" );
_LIT( KLanBearerAgent, "lanagt.agt" );
_LIT( KLanBearerNif, "lannif" );

_LIT( KLanLDDName, "not used" );
_LIT( KLanPDDName, "not used" );

const TInt KLanLastSocketActivityTimeout = -1;
const TInt KLanLastSocketClosedTimeout = -1;

const TBool KDefIpAddrFromServer = ETrue;
const TBool KDefIpDnsAddrFromServer = ETrue;
const TBool KDefIp6DnsAddrFromServer = ETrue;

static const TCmAttribConvTable SLanConvTbl[] = 
    {
    { ELanBaseIfNetworks, ELanBaseRangeMax, NULL },
    { ELanBaseIfNetworks, KCDTIdLANIfNetworks, NULL },        
    { ELanBaseIpNetMask, KCDTIdLANIpNetMask, &CheckIPv4ValidityL,
      R_QTN_NETW_SETT_SUBNET_MASK,
      KIpAddressWidth, EConvCompulsory | EConvIPv4, R_QTN_SELEC_SETTING_COMPULSORY, 0, NULL, NULL },
    { ELanBaseIpGateway, KCDTIdLANIpGateway, &CheckIPv4ValidityL,
      R_QTN_NETW_SETT_DEFAULT_GATEWAY,
      KIpAddressWidth, EConvCompulsory | EConvIPv4, R_QTN_SELEC_SETTING_COMPULSORY, 0, NULL, NULL },
    { ELanBaseIpAddrFromServer, KCDTIdLANIpAddrFromServer, NULL },
    { ELanBaseIpAddr, KCDTIdLANIpAddr, &CheckIPv4ValidityL,
      R_QTN_SET_IP_ADDRESS,
      KIpAddressWidth, EConvIPv4, R_QTN_SET_IP_ADDRESS_DYNAMIC, 0, NULL, NULL },
    { ELanBaseIpDNSAddrFromServer, KCDTIdLANIpDNSAddrFromServer, NULL,
      R_QTN_SET_DNS_SERVERS_IP,
      0, 0, 0, 0, NULL, NULL },
    { ELanBaseIpNameServer1, KCDTIdLANIpNameServer1, &CheckIPv4ValidityL,
      R_QTN_SET_PRIMARY_DNS,
      KMaxIPv4NameServerLength, EConvIPv4, R_QTN_SET_DNS_SERVERS_AUTOMATIC, 0, NULL, NULL },
    { ELanBaseIpNameServer2, KCDTIdLANIpNameServer2, &CheckIPv4ValidityL,
      R_QTN_SET_SECONDARY_DNS,
      KMaxIPv4NameServerLength, EConvIPv4, R_QTN_SET_DNS_SERVERS_AUTOMATIC, 0, NULL, NULL },    
    { ELanBaseIp6DNSAddrFromServer, KCDTIdLANIp6DNSAddrFromServer, NULL,
      R_QTN_SET_DNS_SERVERS_IP,
      0, 0, 0, 0, NULL, NULL },
    { ELanBaseIp6NameServer1, KCDTIdLANIp6NameServer1, &CheckIPv6ValidityL },
    { ELanBaseIp6NameServer2, KCDTIdLANIp6NameServer2, &CheckIPv6ValidityL },
    { ELanBaseIpAddrLeaseValidFrom, KCDTIdLANIpAddrLeaseValidFrom, NULL },
    { ELanBaseIpAddrLeaseValidTo, KCDTIdLANIpAddrLeaseValidTo, NULL },
    { ELanBaseConfigDaemonManagerName, KCDTIdLANConfigDaemonManagerName, NULL },
    { ELanBaseConfigDaemonName, KCDTIdLANConfigDaemonName, NULL },
    { ELanBaseServiceExtensionTableName, KCDTIdLANServiceExtensionTableName, NULL },
    { ELanBaseServiceExtensionTableRecordId, KCDTIdLANServiceExtensionTableRecordId, &CheckRecordIdValidityL },
    { 0,0, NULL }
    };

static const TCmCommonAttrConvArrayItem SCommonConvTbl[] =
{
    { ELanBaseIfNetworks, ECmIFNetworks },
    { ELanBaseIpNetMask, ECmIPNetmask },
    { ELanBaseIpGateway, ECmIPGateway },
    { ELanBaseIpAddrFromServer, ECmIPAddFromServer },
    { ELanBaseIpAddr, ECmIPAddress },
    { ELanBaseIpDNSAddrFromServer, ECmIPDNSAddrFromServer },
    { ELanBaseIpNameServer1, ECmIPNameServer1 },
    { ELanBaseIpNameServer2, ECmIPNameServer2 },
    { ELanBaseIp6DNSAddrFromServer, ECmIP6DNSAddrFromServer },
    { ELanBaseIp6NameServer1, ECmIP6NameServer1 },
    { ELanBaseIp6NameServer2, ECmIP6NameServer2 },
    { ELanBaseIpAddrLeaseValidFrom, ECmIPAddrLeaseValidFrom },
    { ELanBaseIpAddrLeaseValidTo, ECmIPAddrLeaseValidTo },
    { ELanBaseConfigDaemonManagerName, ECmConfigDaemonManagerName },
    { ELanBaseConfigDaemonName, ECmConfigDaemonName },
    { 0, 0 }
    };

// ---------------------------------------------------------------------------
// CCmPluginLanBase::CCmPluginLanBase()
// ---------------------------------------------------------------------------
//
EXPORT_C CCmPluginLanBase::CCmPluginLanBase( TCmPluginInitParam* aInitParam )
    : CCmPluginBaseEng( aInitParam )
    {
    CLOG_CREATE;


    }

EXPORT_C CCmPluginLanBase::~CCmPluginLanBase()
    {
    CLOG_CLOSE;
    }

// ---------------------------------------------------------------------------
// CCmPluginLanBase::ConstructL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CCmPluginLanBase::ConstructL()
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::ConstructL" );
    
    CCmPluginBaseEng::ConstructL();
    
    AddConverstionTableL( (CCDRecordBase**)&iServiceRecord, NULL, SLanConvTbl );
	AddCommonConversionTableL( SCommonConvTbl );
    }

// ---------------------------------------------------------------------------
// CCmPluginLanBase::RunSettingsL()
// ---------------------------------------------------------------------------
//        
EXPORT_C TInt CCmPluginLanBase::RunSettingsL()
    {
    User::Leave( KErrNotSupported );
    return 0;
    }
        
// ---------------------------------------------------------------------------
// CCmPluginLanBase::InitializeWithUiL()
// ---------------------------------------------------------------------------
//        
EXPORT_C TBool CCmPluginLanBase::InitializeWithUiL( 
                                            TBool /*aManuallyConfigure*/ )
    {
    User::Leave(KErrNotSupported);
    return ETrue;
    }

// ---------------------------------------------------------------------------
// CCmPluginLanBase::LoadServiceSettingL()
// ---------------------------------------------------------------------------
//        
EXPORT_C void CCmPluginLanBase::LoadServiceSettingL()
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::LoadServiceSettingL" );
    
    if( TPtrC(KCDTypeNameLANService) == iIapRecord->iServiceType  )
        {
        iServiceRecord = static_cast<CCDLANServiceRecord *>
                    (CCDRecordBase::RecordFactoryL(KCDTIdLANServiceRecord));
        }
    else
        // this IAP service is not supported by this plugin.
        {
        User::Leave( KErrNotSupported );
        }

    CCmPluginBaseEng::LoadServiceSettingL();
    }
    
// ---------------------------------------------------------------------------
// CCmPluginLanBase::ServiceRecord()
// ---------------------------------------------------------------------------
//        
EXPORT_C CCDLANServiceRecord& CCmPluginLanBase::ServiceRecord()const
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::ServiceRecord" );
    return *static_cast<CCDLANServiceRecord*>(iServiceRecord);
    }

// ---------------------------------------------------------------------------
// CCmPluginLanBase::ServiceRecordIdLC
// ---------------------------------------------------------------------------
//
EXPORT_C void CCmPluginLanBase::ServiceRecordIdLC( HBufC* &aName, 
                                                   TUint32& aRecordId )
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::ServiceRecordIdLC" );

    aName = TPtrC( KCDTypeNameLANService ).AllocLC();    
    aRecordId = iServiceRecord->RecordId();
    }

// ---------------------------------------------------------------------------
// CCmPluginLanBase::BearerRecordIdLC()
// ---------------------------------------------------------------------------
//        
EXPORT_C void CCmPluginLanBase::BearerRecordIdLC( HBufC* &aBearerName, 
                                                  TUint32& aRecordId )
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::BearerRecordIdLC" );
                
    CCDLANBearerRecord* tmprec = static_cast<CCDLANBearerRecord*>
                        (CCDRecordBase::RecordFactoryL( KCDTIdLANBearerRecord ));
    CleanupStack::PushL( tmprec );

    tmprec->iRecordName.SetL( TPtrC(iBearerRecName) );
    if ( !tmprec->FindL( Session() ) )
        { // bearer not found -> create dummy values
        CLOG_WRITE( "No bearer found" );

        tmprec->SetRecordId( KCDNewRecordRequest );
        tmprec->iBearerAgent = KLanBearerAgent;
        tmprec->iRecordName = KLanBearerName;
        tmprec->iLanBearerNifName = KLanBearerNif;
        tmprec->iLanBearerLddName = KLanLDDName;
        tmprec->iLanBearerPddName = KLanPDDName;
        tmprec->iLastSocketActivityTimeout = 
                                        (TUint32)KLanLastSocketActivityTimeout;
        tmprec->iLastSocketClosedTimeout = 
                                        (TUint32)KLanLastSocketClosedTimeout;

        tmprec->StoreL( Session() );
        }

    aRecordId = tmprec->RecordId();
    
    CLOG_WRITE_2( "Name: [%S], id: [%d]", 
                  &tmprec->iRecordName.GetL(), 
                  aRecordId );

    CleanupStack::PopAndDestroy( tmprec );

    aBearerName = TPtrC(KCDTypeNameLANBearer).AllocLC();    
    }

// ---------------------------------------------------------------------------
// CCmPluginLanBase::CreateNewServiceRecordL()
// ---------------------------------------------------------------------------
//        
EXPORT_C void CCmPluginLanBase::CreateNewServiceRecordL()
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::CreateNewServiceRecordL" );

    delete iServiceRecord; 
    iServiceRecord = NULL;
    
    iServiceRecord = static_cast<CCDServiceRecordBase *>
                (CCDRecordBase::RecordFactoryL(KCDTIdLANServiceRecord));

    // I do not think that we have to use the default record,
    // but for compatibility with ApEngine, we write all fields 

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


    if( FeatureSupported( KFeatureIdIPv6 ) )
        {
        record->iIfNetworks.SetL( KDefIspIfNetworksIPv4IPv6LAN );
        }
    else
        {
        record->iIfNetworks.SetL( KDefIspIfNetworksIPv4 );
        }

//    record->iIpNetmask.SetL();
    
    record->iIpGateway.SetL( KUnspecifiedIPv4 );        
    record->iIpAddrFromServer.SetL( KDefIpAddrFromServer );
    
    record->iIpAddr.SetL( KUnspecifiedIPv4 );
    
    record->iIpDnsAddrFromServer.SetL( KDefIpDnsAddrFromServer );
    
    record->iIpNameServer1.SetL( KUnspecifiedIPv4 );
    record->iIpNameServer2.SetL( KUnspecifiedIPv4 );
    record->iIp6DnsAddrFromServer.SetL( KDefIp6DnsAddrFromServer );
    record->iIp6NameServer1.SetL( KDynamicIpv6Address );
    record->iIp6NameServer2.SetL( KDynamicIpv6Address );
        
//        record->iIpAddrLeaseValidFrom.SetL();
//        record->iIpAddrLeaseValidTo.SetL();
        
    if ( KDefIpAddrFromServer )
        {
        record->iConfigDaemonManagerName.SetL( KDaemonManagerName );
        record->iConfigDaemonName.SetL( KConfigDaemonName );
        }
    else
        {
        record->iConfigDaemonManagerName.SetL( KEmpty );
        record->iConfigDaemonName.SetL( KEmpty );
        }

//        record->iServiceExtensionTableName.SetL();
//        record->iServiceExtensionTableRecordId.SetL();
    }

// --------------------------------------------------------------------------
// CCmPluginLanBase::PrepareToUpdateRecordsL()
// --------------------------------------------------------------------------
//        
EXPORT_C void CCmPluginLanBase::PrepareToUpdateRecordsL()
    {
    LOGGER_ENTERFN( "CCmPluginLanBase::PrepareToUpdateRecordsL" );
    
    CheckDNSServerAddressL( ETrue, 
                            ServiceRecord().iIp6NameServer1,
                            ServiceRecord().iIp6NameServer2,
                            ServiceRecord().iIp6DnsAddrFromServer );
                            
    CheckDNSServerAddressL( EFalse,
                            ServiceRecord().iIpNameServer1,
                            ServiceRecord().iIpNameServer2,
                            ServiceRecord().iIpDnsAddrFromServer );
    }