/*
* Copyright (c) 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: TUN Driver plug-in IF implementation class.
*
*/
#include <AknsUtils.h>
#include <cmpluginvpn.mbg>
#include <data_caging_path_literals.hrh>
#include "cmlogger.h"
#include "cmdestinationimpl.h"
#include "cmplugintundriver.h"
using namespace CMManager;
using namespace CommsDat;
const TUint32 KDefaultPriorityTUNDriver = 0;
_LIT( KPluginTUNDriverFileIcons, "z:cmplugintundriver.mbm" );
_LIT(KTUNDriverBearerName,"TUNDriverBearer");
#define KCDAgentNameTUNDriver _S("tundriveragt.agt")
_LIT(KTUNDriverTunnelAgent,"tundriveragt.agt");
#define KCDInterfaceNameTUNDriver _S("tundriver")
_LIT(KTUNDriverInterfaceName,"tundriver");
const TInt KLanLastSocketActivityTimeout = -1;
const TInt KLanLastSocketClosedTimeout = -1;
const TBool KDefIpAddrFromServer = EFalse;
const TBool KDefIpDnsAddrFromServer = EFalse;
const TBool KDefIp6DnsAddrFromServer = EFalse;
_LIT( KEmpty, "");
static const TCmAttribConvTable STUNDriverConvTbl[] =
{
{ ETUNDriverIfNetworks, ETUNDriverRangeMax, NULL },
{ ETUNDriverIfNetworks, KCDTIdLANIfNetworks, NULL },
{ ETUNDriverIpNetMask, KCDTIdLANIpNetMask, &CheckIPv4ValidityL },
{ ETUNDriverIpGateway, KCDTIdLANIpGateway, &CheckIPv4ValidityL },
{ ETUNDriverIpAddrFromServer, KCDTIdLANIpAddrFromServer, NULL },
{ ETUNDriverIpAddr, KCDTIdLANIpAddr, &CheckIPv4ValidityL },
{ ETUNDriverIpDNSAddrFromServer, KCDTIdLANIpDNSAddrFromServer, NULL },
{ ETUNDriverIpNameServer1, KCDTIdLANIpNameServer1, &CheckIPv4ValidityL },
{ ETUNDriverIpNameServer2, KCDTIdLANIpNameServer2, &CheckIPv4ValidityL },
{ ETUNDriverIp6DNSAddrFromServer, KCDTIdLANIp6DNSAddrFromServer, NULL },
{ ETUNDriverIp6NameServer1, KCDTIdLANIp6NameServer1, &CheckIPv4ValidityL },
{ ETUNDriverIp6NameServer2, KCDTIdLANIp6NameServer2, &CheckIPv4ValidityL },
{ ETUNDriverIpAddrLeaseValidFrom, KCDTIdLANIpAddrLeaseValidFrom, NULL },
{ ETUNDriverIpAddrLeaseValidTo, KCDTIdLANIpAddrLeaseValidTo, NULL },
{ ETUNDriverConfigDaemonManagerName, KCDTIdLANConfigDaemonManagerName, NULL },
{ ETUNDriverConfigDaemonName, KCDTIdLANConfigDaemonName, NULL },
{ ETUNDriverServiceExtensionTableName, KCDTIdLANServiceExtensionTableName, NULL },
{ ETUNDriverServiceExtensionTableRecordId, KCDTIdLANServiceExtensionTableRecordId, NULL },
{ 0, 0, NULL }
};
static const TCmCommonAttrConvArrayItem STUNDriverCommonConvTbl[] =
{
{ ETUNDriverIfNetworks, ECmIFNetworks },
{ ETUNDriverIpNetMask, ECmIPNetmask },
{ ETUNDriverIpGateway, ECmIPGateway },
{ ETUNDriverIpAddrFromServer, ECmIPAddFromServer },
{ ETUNDriverIpAddr, ECmIPAddress },
{ ETUNDriverIpDNSAddrFromServer, ECmIPDNSAddrFromServer },
{ ETUNDriverIpNameServer1, ECmIPNameServer1 },
{ ETUNDriverIpNameServer2, ECmIPNameServer2 },
{ ETUNDriverIp6DNSAddrFromServer, ECmIP6DNSAddrFromServer },
{ ETUNDriverIp6NameServer1, ECmIP6NameServer1 },
{ ETUNDriverIp6NameServer2, ECmIP6NameServer2 },
{ ETUNDriverIpAddrLeaseValidFrom, ECmIPAddrLeaseValidFrom },
{ ETUNDriverIpAddrLeaseValidTo, ECmIPAddrLeaseValidTo },
{ ETUNDriverConfigDaemonManagerName, ECmConfigDaemonManagerName },
{ ETUNDriverConfigDaemonName, ECmConfigDaemonName },
{ 0, 0 }
};
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::NewL()
// --------------------------------------------------------------------------
//
CCmPluginTUNDriver* CCmPluginTUNDriver::NewL( TCmPluginInitParam* aInitParam )
{
CCmPluginTUNDriver* self = new( ELeave ) CCmPluginTUNDriver( aInitParam );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::~CCmPluginTUNDriver()
// --------------------------------------------------------------------------
//
CCmPluginTUNDriver::~CCmPluginTUNDriver()
{
AdditionalReset();
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::CreateInstanceL
// --------------------------------------------------------------------------
//
CCmPluginBaseEng* CCmPluginTUNDriver::CreateInstanceL( TCmPluginInitParam& aInitParam ) const
{
CCmPluginTUNDriver* self = new( ELeave ) CCmPluginTUNDriver( &aInitParam );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::CCmPluginTUNDriver()
// --------------------------------------------------------------------------
//
CCmPluginTUNDriver::CCmPluginTUNDriver( TCmPluginInitParam* aInitParam )
: CCmPluginLanBase( aInitParam )
{
CLOG_CREATE;
iBearerType = KPluginTUNDriverBearerTypeUid;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::ConstructL()
// --------------------------------------------------------------------------
//
void CCmPluginTUNDriver::ConstructL()
{
CCmPluginLanBase::ConstructL();
iBearerRecName = KCDTypeNameVirtualBearer;
AddConverstionTableL( (CCDRecordBase**)&iServiceRecord, NULL, STUNDriverConvTbl );
AddCommonConversionTableL( STUNDriverCommonConvTbl );
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::GetIntAttributeL()
// --------------------------------------------------------------------------
//
TUint32 CCmPluginTUNDriver::GetIntAttributeL( const TUint32 aAttribute ) const
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::GetIntAttributeL" );
TUint32 retVal( 0 );
switch( aAttribute )
{
case ECmBearerIcon:
{
MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();
TAknsItemID id;
TParse mbmFile;
User::LeaveIfError( mbmFile.Set( KPluginTUNDriverFileIcons,
&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 = KCommDbBearerLAN;
}
break;
case ECmDefaultUiPriority:
case ECmDefaultPriority:
{
retVal = aAttribute == ECmDefaultPriority ?
GlobalBearerPriority( TPtrC(KCDTypeNameLANService) ) :
GlobalUiBearerPriority( TPtrC(KCDTypeNameLANService) );
if ( retVal == KDataMobilitySelectionPolicyPriorityWildCard )
{
retVal = KDefaultPriorityTUNDriver;
}
}
break;
default:
{
retVal = CCmPluginBaseEng::GetIntAttributeL( aAttribute );
}
}
return retVal;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::CanHandleIapIdL()
// --------------------------------------------------------------------------
//
TBool CCmPluginTUNDriver::CanHandleIapIdL( TUint32 aIapId ) const
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::CanHandleIapIdL1" );
TBool retVal( EFalse );
CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>
(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
CleanupStack::PushL( iapRecord );
iapRecord->SetRecordId( aIapId );
TRAPD( err, iapRecord->LoadL( Session() ));
if( !err )
{
CanHandleIapIdL( iapRecord );
}
CleanupStack::PopAndDestroy( iapRecord );
return retVal;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::CanHandleIapIdL()
// --------------------------------------------------------------------------
//
TBool CCmPluginTUNDriver::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::CanHandleIapIdL" );
TBool retVal( EFalse );
if( TPtrC( aIapRecord->iServiceType ) == TPtrC(KCDTypeNameLANService) &&
TPtrC( aIapRecord->iBearerType ) == TPtrC(KCDTypeNameVirtualBearer) )
{
CMDBRecordSet<CCDVirtualBearerRecord>* bearersRS =
new ( ELeave ) CMDBRecordSet<CCDVirtualBearerRecord>(KCDTIdVirtualBearerRecord);
CleanupStack::PushL( bearersRS );
CCDVirtualBearerRecord* bearerRecord =
static_cast<CCDVirtualBearerRecord *>( CCDRecordBase::RecordFactoryL( KCDTIdVirtualBearerRecord ) );
CleanupStack::PushL( bearerRecord );
// Find entries used "tundriveragt.agt" as agent from Table VirtualBearer
bearerRecord->iBearerAgent.SetL( KTUNDriverTunnelAgent );
bearerRecord->iVirtualBearerNifName.SetL( KTUNDriverInterfaceName );
bearersRS->iRecords.AppendL( bearerRecord );
CleanupStack::Pop( bearerRecord );
bearerRecord = NULL;
if ( bearersRS->FindL( Session() ) )
{
TUint32 recordId = (*bearersRS)[0]->RecordId();
TPtrC bearerName( (*bearersRS)[0]->iRecordName.GetL() );
TPtrC bearerAgent( (*bearersRS)[0]->iBearerAgent.GetL() );
TPtrC bearerInterface( (*bearersRS)[0]->iVirtualBearerNifName.GetL() );
// Further comparing record ID referred to by this VPN IAP with entry ID in table VirtualBearer
// And also comparing bear name with our expected one "vpnbearer"
if ( bearerAgent == TPtrC( KCDAgentNameTUNDriver ) &&
bearerInterface == TPtrC( KCDInterfaceNameTUNDriver ) )
{
retVal = ETrue;
}
}
CleanupStack::PopAndDestroy( bearersRS );
}
return retVal;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::RunSettingsL()
// --------------------------------------------------------------------------
//
TInt CCmPluginTUNDriver::RunSettingsL()
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::RunSettingsL" );
User::Leave( KErrNotSupported );
return KErrNotSupported;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::LoadServiceSettingL()
// --------------------------------------------------------------------------
//
void CCmPluginTUNDriver::LoadServiceSettingL()
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::LoadServiceSettingL" );
if( TPtrC(KCDTypeNameLANService) == iIapRecord->iServiceType )
{
iServiceRecord = static_cast<CCDLANServiceRecord *>
( CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) );
}
else
{
User::Leave( KErrNotSupported );
}
CCmPluginBaseEng::LoadServiceSettingL();
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::InitializeWithUiL()
// --------------------------------------------------------------------------
//
TBool CCmPluginTUNDriver::InitializeWithUiL( TBool /*aManuallyConfigure*/ )
{
User::Leave( KErrNotSupported );
return ETrue;
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::ServiceRecord()
// --------------------------------------------------------------------------
//
CCDLANServiceRecord& CCmPluginTUNDriver::ServiceRecord() const
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::ServiceRecord" );
return *static_cast<CCDLANServiceRecord*>( iServiceRecord );
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::CreateNewServiceRecordL()
// --------------------------------------------------------------------------
//
void CCmPluginTUNDriver::CreateNewServiceRecordL()
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::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->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 );
if ( KDefIpAddrFromServer )
{
record->iConfigDaemonManagerName.SetL( KDaemonManagerName );
record->iConfigDaemonName.SetL( KConfigDaemonName );
}
else
{
record->iConfigDaemonManagerName.SetL( KEmpty );
record->iConfigDaemonName.SetL( KEmpty );
}
}
// ---------------------------------------------------------------------------
// CCmPluginTUNDriver::ServiceRecordIdLC
// ---------------------------------------------------------------------------
//
void CCmPluginTUNDriver::ServiceRecordIdLC( HBufC* &aName, TUint32& aRecordId )
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::ServiceRecordIdLC" );
aName = TPtrC( KCDTypeNameLANService ).AllocLC();
aRecordId = iServiceRecord->RecordId();
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::BearerRecordIdLC()
// --------------------------------------------------------------------------
//
void CCmPluginTUNDriver::BearerRecordIdLC( HBufC* &aBearerName, TUint32& aRecordId )
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::BearerRecordIdLC" );
CMDBRecordSet<CCDVirtualBearerRecord>* bearersRS =
new(ELeave) CMDBRecordSet<CCDVirtualBearerRecord>
(KCDTIdVirtualBearerRecord);
CleanupStack::PushL( bearersRS );
CCDVirtualBearerRecord* tmprec = static_cast<CCDVirtualBearerRecord*>
(CCDRecordBase::RecordFactoryL( KCDTIdVirtualBearerRecord ));
CleanupStack::PushL( tmprec );
tmprec->iBearerAgent.SetL( KTUNDriverTunnelAgent );
bearersRS->iRecords.AppendL( tmprec );
CleanupStack::Pop( tmprec );
tmprec = NULL;
if ( !bearersRS->FindL( Session() ) )
// No bearer record found -> create a default one.
{
tmprec = static_cast<CCDVirtualBearerRecord *>
(CCDRecordBase::RecordFactoryL(KCDTIdVirtualBearerRecord));
CleanupStack::PushL(tmprec);
tmprec->iRecordName.SetL( KTUNDriverBearerName );
tmprec->iBearerAgent.SetL( KTUNDriverTunnelAgent );
tmprec->iVirtualBearerNifName.SetL(KTUNDriverInterfaceName);
tmprec->iLastSocketActivityTimeout = (TUint32)KLanLastSocketActivityTimeout;
tmprec->iLastSessionClosedTimeout = (TUint32) KLanLastSocketClosedTimeout;
tmprec->iLastSocketClosedTimeout = (TUint32)KLanLastSocketActivityTimeout;
tmprec->SetRecordId( KCDNewRecordRequest );
tmprec->StoreL( Session() );
aRecordId = tmprec->RecordId();
CleanupStack::PopAndDestroy(tmprec);
}
else
{
aRecordId = (*bearersRS)[0]->RecordId();
}
CleanupStack::PopAndDestroy( bearersRS );
aBearerName = TPtrC( KCDTypeNameVirtualBearer ).AllocLC();
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::PrepareToUpdateRecordsL()
// --------------------------------------------------------------------------
//
void CCmPluginTUNDriver::PrepareToUpdateRecordsL()
{
LOGGER_ENTERFN( "CCmPluginTUNDriver::PrepareToUpdateRecordsL" );
CheckDNSServerAddressL( ETrue,
ServiceRecord().iIp6NameServer1,
ServiceRecord().iIp6NameServer2,
ServiceRecord().iIp6DnsAddrFromServer );
CheckDNSServerAddressL( EFalse,
ServiceRecord().iIpNameServer1,
ServiceRecord().iIpNameServer2,
ServiceRecord().iIpDnsAddrFromServer );
}
// --------------------------------------------------------------------------
// CCmPluginTUNDriver::AdditionalReset()
// --------------------------------------------------------------------------
//
void CCmPluginTUNDriver::AdditionalReset()
{
}
// eof