--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/sit/src/vpnconnstarter.cpp Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,652 @@
+/*
+* Copyright (c) 2003-2009 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: VPN connection starter
+*
+*/
+
+#include <e32base.h>
+#include <commsdat.h>
+#include <cmmanagerext.h>
+
+#if defined(__PFX_MIP4__)
+#include <FeatMgr.h>
+#endif
+
+#include "vpnconnstarter.h"
+#include "ikepolparser.h"
+#include "ipsecpolparser.h"
+#include "log.h"
+
+// Task handling states
+enum TConnStarterState
+ {
+ KStateStartRealIap,
+ KStateRealIapConnected,
+ KStateGetVpnPolicy,
+ KStateActivateKmd,
+ KStateAfterActivateKmd,
+ KStateLoadIpsecPolicy,
+ KStateAfterLoadIpsecPolicy,
+ KStateActivateIpsecPolicy,
+ KStateAfterActivateIpsecPolicy
+ };
+
+
+CVpnConnStarter* CVpnConnStarter::NewL(MTaskHandlerManager* aManager,
+ const TTaskArrivedEventData& aTaskInfo)
+ {
+ LOG(Log::Printf(_L("CVpnConnStarter::NewL - begin\n")));
+ CVpnConnStarter* self = new (ELeave) CVpnConnStarter(aManager, aTaskInfo);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(); // self
+ LOG(Log::Printf(_L("CVpnConnStarter::NewL - end\n")));
+ return self;
+ }
+
+CVpnConnStarter::CVpnConnStarter(MTaskHandlerManager* aManager,
+ const TTaskArrivedEventData& aTaskInfo)
+ : CTaskHandler(aManager, aTaskInfo, EStartVpnConnCancelEvent, &iEventSpecDes),
+ iVpnAddressInfoDes(iVpnAddressInfo),
+ iIfInfoDes(iIfInfo)
+ {
+ iIfInfo.iRealIapId = 0;
+ iIfInfo.iRealNetId = 0;
+ }
+
+void CVpnConnStarter::ConstructL()
+ {
+ CActiveScheduler::Add(this);
+ User::LeaveIfError(iEventMediator.Connect());
+ User::LeaveIfError(iVpnServ.Connect());
+ User::LeaveIfError(iKmdServ.Connect());
+ User::LeaveIfError(iPolicyServ.Connect());
+#if defined(__PFX_MIP4__)
+ FeatureManager::InitializeLibL();
+#endif
+ }
+
+CVpnConnStarter::~CVpnConnStarter()
+ {
+ LOG(Log::Printf(_L("CVpnConnStarter::~CVpnConnStarter\n")));
+ Cancel();
+ iEventMediator.Close();
+ iVpnServ.Close();
+ iKmdServ.Close();
+ iPolicyServ.Close();
+
+ delete iIkePolicyData;
+ delete iIpsecPolicyData;
+ delete iCustomTs;
+
+ RELEASE_EVENT_LOGGER;
+#if defined(__PFX_MIP4__)
+ FeatureManager::UnInitializeLib();
+#endif
+ }
+
+void CVpnConnStarter::StartTaskHandling()
+ {
+ // Read input parameters.
+ // Changing the content of iEventSpecDes is not allowed
+ iVpnIapId = iEventSpecDes().iIfInfo.iVpnIapId;
+ GotoState(KStateStartRealIap);
+ }
+
+void CVpnConnStarter::ChangeStateL()
+ {
+ switch (NextState())
+ {
+ case KStateStartRealIap:
+ StateStartRealIap();
+ break;
+
+ case KStateRealIapConnected:
+ StateRealIapConnectedL();
+ break;
+
+ case KStateGetVpnPolicy:
+ StateGetVpnPolicyL();
+ break;
+
+ case KStateLoadIpsecPolicy:
+ StateLoadIpsecPolicy();
+ break;
+
+ case KStateAfterLoadIpsecPolicy:
+ StateAfterLoadIpsecPolicyL();
+ break;
+
+ case KStateActivateIpsecPolicy:
+ StateActivateIpsecPolicy();
+ break;
+
+ case KStateAfterActivateIpsecPolicy:
+ StateAfterActivateIpsecPolicyL();
+ break;
+
+ case KStateActivateKmd:
+ StateActivateKmdL();
+ break;
+
+ case KStateAfterActivateKmd:
+ StateAfterActivateKmdL();
+ break;
+
+ default:
+ User::Panic(KSitName, EPanicInvalidTaskHandlerState);
+ }
+ }
+
+void CVpnConnStarter::CancelOngoingOperation()
+ {
+ LOG_EVENT(R_VPN_MSG_VPN_IAP_ACT_CANCEL, NULL, 0, 0);
+
+ switch (CurrState())
+ {
+ case KStateStartRealIap:
+ DEB(LOG(Log::Printf(_L("Canceling start real connection\n") ));)
+ iKmdServ.CancelStartRealConnection();
+ break;
+ case KStateRealIapConnected:
+ case KStateGetVpnPolicy:
+ case KStateAfterActivateKmd:
+ case KStateAfterLoadIpsecPolicy:
+ case KStateAfterActivateIpsecPolicy:
+ // There's no ongoing external request to cancel
+ break;
+
+ case KStateActivateKmd:
+ DEB(LOG(Log::Printf(_L("Canceling KMD activate\n") ));)
+ iKmdServ.CancelActivate();
+ break;
+
+ case KStateLoadIpsecPolicy:
+ DEB(LOG(Log::Printf(_L("Canceling Ipsec policy load\n") ));)
+ iPolicyServ.CancelLoad();
+ break;
+
+ case KStateActivateIpsecPolicy:
+ DEB(LOG(Log::Printf(_L("Canceling Ipsec policy activate\n") ));)
+ iPolicyServ.CancelActivate();
+ break;
+
+ default:
+ User::Panic(KSitName, EPanicInvalidTaskHandlerState);
+ }
+
+ RollbackProcess();
+ }
+
+void CVpnConnStarter::StateStartRealIap()
+ {
+ SetCurrState(KStateStartRealIap);
+
+ DEB(LOG(Log::Printf(_L("StateStartRealIap, VPN IAP Id:%d\n"),
+ iVpnIapId));)
+ iKmdServ.StartRealConnection(iVpnIapId, iIfInfoDes, iStatus);
+ SetNextState(KStateRealIapConnected);
+ SetActive();
+ }
+
+void CVpnConnStarter::StateRealIapConnectedL()
+ {
+ SetCurrState(KStateRealIapConnected);
+ DEB(LOG(Log::Printf(_L("StateRealIapConnected:%d\n"), iStatus.Int()));)
+ User::LeaveIfError( iStatus.Int() );
+ INIT_EVENT_LOGGER(iEventMediator,
+ iVpnIapId, iIfInfoDes().iRealIapId);
+ LOG_EVENT(R_VPN_MSG_VPN_IAP_ACT_START, this, 0, 0);
+ GotoState(KStateGetVpnPolicy);
+ }
+
+void CVpnConnStarter::StateGetVpnPolicyL()
+ {
+ SetCurrState(KStateGetVpnPolicy);
+
+ HBufC8* vpnPolicyData = NULL;
+ DEB(LOG(Log::Printf(_L("Starting to get VPN policy: %S\n"),
+ &(iEventSpecDes().iPolicyId) ));)
+ // Get VPN policy data
+ User::LeaveIfError(
+ iVpnServ.GetPolicyData(iEventSpecDes().iPolicyId, vpnPolicyData));
+ CleanupStack::PushL(vpnPolicyData);
+
+ // Convert to 16 bit
+ HBufC16* vpnPolicyData16 = CSit::To16BitL(*vpnPolicyData);
+ CleanupStack::PushL(vpnPolicyData16);
+
+ // Buffer containing Nokia NAT-T specific traffic selectors
+ // if specified in IKE policy
+ delete iCustomTs;
+ iCustomTs = NULL;
+ iCustomTs = HBufC8::NewL(256);
+
+ // Extract IKE and IPSec policies from the VPN policy
+ // Also stores custom Traffic Selectors if needed
+ GetIkePolicyFromVpnPolicyL(*vpnPolicyData16);
+ DEB(LOG(Log::Printf(_L("IKE policy parsing succeeded\n")));)
+
+ GetIpsecPolicyFromVpnPolicyL(*vpnPolicyData16);
+ DEB(LOG(Log::Printf(_L("Ipsec policy parsing succeeded\n")));)
+
+ // Insert stored traffic selectors to IPsec policy
+ InsertCustomTrafficSelectorsL();
+
+ // Custom traffic selectors are no longer needed since
+ // they were given to IPsec in above
+ delete iCustomTs;
+ iCustomTs = NULL;
+
+ CleanupStack::PopAndDestroy(2); // vpnPolicyData16, vpnPolicyData
+
+ GotoState(KStateLoadIpsecPolicy);
+ }
+
+void CVpnConnStarter::StateActivateKmdL()
+ {
+ SetCurrState(KStateActivateKmd);
+
+ DEB(LOG(Log::Printf(_L("Starting KMD activate\n")));)
+ iKmdServ.Activate(iVpnIapId,
+ iEventSpecDes().iIfInfo.iVPNIfName,
+ *iIkePolicyData,
+ iVpnAddressInfoDes,
+ iStatus);
+
+ SetNextState(KStateAfterActivateKmd);
+ SetActive();
+ }
+
+void CVpnConnStarter::StateAfterActivateKmdL()
+ {
+ SetCurrState(KStateAfterActivateKmd);
+
+ DEB(LOG(Log::Printf(
+ _L("KMD activate completed, status = %d, VPN IAP Id = %d\n"),
+ iStatus.Int(), iVpnIapId));)
+ // Leave if KMD activation failed
+ User::LeaveIfError(iStatus.Int());
+
+ LOG_EVENT(R_VPN_MSG_VPN_IAP_ACTIVATED,
+ &(iVpnAddressInfo.iVPNIfAddr), iStatus.Int(), 0);
+
+ TaskComplete(KErrNone);
+ }
+
+void CVpnConnStarter::StateLoadIpsecPolicy()
+ {
+ SetCurrState(KStateLoadIpsecPolicy);
+
+ DEB(LOG(Log::Printf(_L("Starting to load Ipsec policy\n")));)
+ LoadIpsecPolicy();
+
+ SetNextState(KStateAfterLoadIpsecPolicy);
+ SetActive();
+ }
+
+void CVpnConnStarter::StateAfterLoadIpsecPolicyL()
+ {
+ SetCurrState(KStateAfterLoadIpsecPolicy);
+ DEB(LOG(Log::Printf(
+ _L("Ipsec policy load completed, status = %d\n"), iStatus.Int()));)
+ // Log some debug data if policy loading failed
+ if (iStatus.Int() == ESelectorConflict)
+ {
+ DEB(TPolicyNameInfo conflictInfo;)
+ DEB(TInt err = iPolicyServ.GetDebugInfo(conflictInfo, KConflictingPolicyInfo));
+
+ DEB(if (!err))
+ DEB(LOG(Log::Printf(_L("Additional debug info: %S\n"), &conflictInfo));)
+ }
+
+ if (iStatus.Int() == EParsingError)
+ {
+ DEB(typedef TBuf<200> TParsingErrorInfo;)
+ DEB(TParsingErrorInfo errorInfo;)
+ DEB(TInt err = iPolicyServ.GetDebugInfo(errorInfo, KParsingErrorInfo));
+
+ DEB(if (!err))
+ DEB(LOG(Log::Printf(_L("Additional debug info: %S\n"), &errorInfo));)
+ }
+
+ // Leave if policy loading failed
+ User::LeaveIfError(iStatus.Int());
+
+ GotoState(KStateActivateIpsecPolicy);
+ }
+
+void CVpnConnStarter::StateActivateIpsecPolicy()
+ {
+ SetCurrState(KStateActivateIpsecPolicy);
+
+ DEB(LOG(Log::Printf(_L("Activating Ipsec policy, handle = %d\n"), iIpsecPolicyHandleDes()));)
+ iPolicyServ.ActivatePolicy(iIpsecPolicyHandleDes(), iStatus);
+
+ SetNextState(KStateAfterActivateIpsecPolicy);
+ SetActive();
+ }
+
+void CVpnConnStarter::StateAfterActivateIpsecPolicyL()
+ {
+ DEB(LOG(Log::Printf(_L("Ipsec policy activated, status = %d\n"), iStatus.Int()));)
+
+ User::LeaveIfError(iStatus.Int());
+
+ GotoState(KStateActivateKmd);
+ }
+
+void CVpnConnStarter::ReportResult(TInt aStatus)
+ {
+ DEB(LOG(Log::Printf(_L("CVpnConnStarter::ReportResult\n")));)
+ // Report the startup result with associated
+ // information to the Event Mediator
+ TStartVpnConnEventData eventData;
+
+ eventData.iTaskStatus = aStatus;
+
+ if (aStatus == KErrNone)
+ {
+ eventData.iIkePolicyHandle.iHandle = iVpnIapId;
+ eventData.iIpsecPolicyHandle = iIpsecPolicyHandleDes();
+ eventData.iVpnAddressInfo = iVpnAddressInfo;
+ eventData.iIapId = iIfInfo.iRealIapId;
+ eventData.iNetId = iIfInfo.iRealNetId;
+ DEB(LOG(Log::Printf(_L("Iap:%d Net:%d\n"),
+ eventData.iIapId, eventData.iNetId));)
+ }
+
+ TPckg<TStartVpnConnEventData> eventDataDes(eventData);
+
+ ReportEvent(EStartVpnConnEvent, iEventSpecDes, eventDataDes);
+
+ LOG_EVENT(R_VPN_MSG_VPN_IAP_ACT_END,
+ &(iEventSpecDes().iPolicyId), aStatus, 0);
+ }
+
+TInt CVpnConnStarter::RunError(TInt aError)
+ {
+ LOG_EVENT(R_VPN_MSG_VPN_IAP_ACT_FAILED, NULL, aError, 0);
+
+ RollbackProcess();
+ TaskComplete(aError);
+ return KErrNone;
+ }
+
+void CVpnConnStarter::RollbackProcess()
+ {
+ // If the VPN connection activation process
+ // fails at some point, we may need to reverse
+ // some of the actions that we've done:
+ // - If the KMD has been activated (the IKE policy has been loaded),
+ // deactivate KMD (unload IKE policy)
+ // - If the IPSec policy has been loaded and activated,
+ // unload the policy
+ // No actions are needed regarding the real IAP connection
+ // as it will be closed by the system in the lack of users.
+
+ DEB(LOG(Log::Printf(_L("Deactivating IKE policy due VPN activation error, VPN IAP Id = %d\n"),iVpnIapId));)
+ iKmdServ.StopVpnConnection(iVpnIapId, TKmdStopConnection::ENormal);
+
+ if (iIpsecPolicyHandleDes().iHandle != 0)
+ {
+ DEB(LOG(Log::Printf(_L("Unloading Ipsec policy due VPN activation error, VPN IAP Id = %d\n"),iVpnIapId));)
+ TRequestStatus status;
+ iPolicyServ.UnloadPolicy(iIpsecPolicyHandleDes(), status);
+ User::WaitForRequest(status);
+ }
+ }
+
+void CVpnConnStarter::ResolveIpsecFQDNL(CSecPolBundleList* aSecPolBundleList)
+ {
+ if (aSecPolBundleList)
+ {
+ for (TInt i(0); i<aSecPolBundleList->Count(); ++i)
+ {
+ CSecpolBundleItem* item = aSecPolBundleList->At(i);
+ HBufC* dnsname = item->iTunnelEpFQDN;
+
+ TInetAddr result = ResolveFQDNL(*dnsname);
+ // 39 for ipv6
+ TBuf<39> ipAddress;
+ result.Output( ipAddress );
+ item->iTunnel.Input(ipAddress);
+ DEB(LOG(Log::Printf(_L("Resolved:%S\n"), &ipAddress));)
+ }
+ }
+ }
+
+void CVpnConnStarter::ResolveIkeFQDNL(CIkeData* aIkeData)
+ {
+ ASSERT(aIkeData);
+ if (aIkeData->iFQDNAddr)
+ {
+ TInetAddr result = ResolveFQDNL(aIkeData->iFQDNAddr->GetData());
+ // 39 for ipv6
+ TBuf<39> ipAddress;
+ result.Output( ipAddress );
+ aIkeData->iAddr.Input(ipAddress);
+ DEB(LOG(Log::Printf(_L("Resolved:%S\n"), &ipAddress));)
+ }
+ }
+
+TInetAddr CVpnConnStarter::ResolveFQDNL(const TDesC& aAddress)
+ {
+ DEB(LOG(Log::Printf(_L("ResolveFQDNL:%S\n"), &aAddress));)
+ TRequestStatus status;
+ TNameEntry result;
+ iKmdServ.ResolveAddress(iVpnIapId, aAddress, result, status);
+ User::WaitForRequest(status);
+ User::LeaveIfError(status.Int());
+ TInetAddr address(result().iAddr);
+ return address;
+ }
+
+void CVpnConnStarter::FormCustomTrafficSelectorsL(CIkeData *aIkeData)
+ {
+ // Add Nokia NAT-T specific traffic selectors to IPsec
+ // custom traffic selector buffer
+ if (aIkeData->iUseNatProbing)
+ {
+ // Default port for Nokia NAT-T
+ TInt port(KNokiaNattDefaultPort);
+ if (aIkeData->iEspUdpPort)
+ port = aIkeData->iEspUdpPort;
+
+ TBuf8<39> addr, mask;
+ TBuf<39> buffer;
+ aIkeData->iAddr.Output(buffer);
+ addr.Copy(buffer);
+ aIkeData->iMask.Output(buffer);
+ mask.Copy(buffer);
+
+ HBufC8 *tsBuffer = HBufC8::NewLC(128);
+ tsBuffer->Des().Format(_L8("remote %S %S local_port %d = { }\n"),
+ &addr, &mask, port);
+ DEB(LOG(Log::Printf(_L8("Custom TS:%S\n"), tsBuffer));)
+ // Make sure that TS fits in the ts buffer
+ if (iCustomTs->Des().MaxLength() < iCustomTs->Length() + tsBuffer->Length())
+ {
+ iCustomTs = iCustomTs->ReAllocL(iCustomTs->Length() + tsBuffer->Length());
+ }
+ iCustomTs->Des().Append(*tsBuffer);
+ CleanupStack::PopAndDestroy(tsBuffer);
+ }
+ }
+
+void CVpnConnStarter::InsertCustomTrafficSelectorsL()
+ {
+ _LIT8(KSearchTerm, "[POLICY]\n");
+ TInt pos = iIpsecPolicyData->Find(KSearchTerm);
+ if (pos != KErrNotFound)
+ {
+ HBufC8 *newIpsecPolicyData = HBufC8::NewL(
+ iIpsecPolicyData->Length() + iCustomTs->Length());
+ pos += KSearchTerm().Length();
+
+ // Add data to "[POLICY]\n"
+ newIpsecPolicyData->Des().Append(iIpsecPolicyData->Des().Left(pos));
+
+ // Add custom traffic selectors
+ newIpsecPolicyData->Des().Append(*iCustomTs);
+
+ // Add rest of the original data
+ newIpsecPolicyData->Des().Append(iIpsecPolicyData->Des().Right(
+ iIpsecPolicyData->Length() - pos));
+
+ delete iIpsecPolicyData;
+ iIpsecPolicyData = newIpsecPolicyData;
+
+ DEB(LOG(Log::Write(*iIpsecPolicyData)));
+ }
+ }
+
+void CVpnConnStarter::GetIkePolicyFromVpnPolicyL(const TDesC& aVpnPolicy)
+ {
+ CIkeDataArray* ikeList = CIkeDataArray::NewL(1);
+ CleanupStack::PushL(ikeList);
+
+ TIkeParser ikeParser(aVpnPolicy);
+ ikeParser.ParseIKESectionsL(ikeList);
+
+ iIkePolicyData = HBufC8::NewL(KIkePolicyBufferSizeIncrement);
+ const TInt maxRetrans(8);
+ const TInt maxTraceFileSize(16);
+ User::LeaveIfError(ikeParser.GeneralInfoWrite(ikeList->iMaxLifetimeSec,
+ ikeList->iMaxLifetimeKB,
+ maxRetrans,
+ maxTraceFileSize,
+ iIkePolicyData));
+
+ for (TInt i(0); i < ikeList->Count(); i++)
+ {
+ CIkeData* ikeData = ikeList->At(i);
+ ResolveIkeFQDNL(ikeData);
+ FormCustomTrafficSelectorsL(ikeData);
+ User::LeaveIfError(ikeParser.MainWrite(ikeData, iIkePolicyData));
+ }
+
+ CleanupStack::PopAndDestroy(ikeList);
+ }
+
+void CVpnConnStarter::GetIpsecPolicyFromVpnPolicyL(const TDesC& aVpnPolicy)
+ {
+ CIpSecurityPiece* pieceData = new (ELeave) CIpSecurityPiece;
+ CleanupStack::PushL(pieceData);
+ pieceData->ConstructL();
+
+ TIpSecParser parser(aVpnPolicy);
+
+ TInt ret = parser.ParseAndIgnoreIKEL(pieceData);
+
+ if (ret != KErrNone)
+ {
+ HBufC* errorInfo = HBufC16::NewL(200);
+ errorInfo->Des().Copy(pieceData->iErrorInfo);
+ LOG(TPtr ptr = errorInfo->Des(); Log::Printf(_L("Parsing error info: %S\n"), &ptr));
+ delete errorInfo;
+ CleanupStack::PopAndDestroy(); // pieceData
+ User::Leave(ret);
+ }
+
+ ResolveIpsecFQDNL(pieceData->FQDNAddressListL());
+
+ iIpsecPolicyData = HBufC8::NewL(KPolicyBufferSizeIncrement);
+ ret = parser.Write(pieceData, iIpsecPolicyData);
+
+ if (ret != KErrNone)
+ {
+ LOG(Log::Printf(_L("Ipsec policy write error: %d\n"), ret));
+ CleanupStack::PopAndDestroy(); // pieceData
+ User::Leave(ret);
+ }
+
+ CleanupStack::PopAndDestroy(); // pieceData
+ }
+
+void CVpnConnStarter::LoadIpsecPolicy()
+ {
+ // Specify network IDs for tunnel end-point and selector definitions
+ iZoneInfoSetDes().iSelectorZone.iScope = KScopeNetwork;
+ iZoneInfoSetDes().iSelectorZone.iId = iEventSpecDes().iIfInfo.iVpnNetId;
+ iZoneInfoSetDes().iEndPointZone.iScope = KScopeNetwork;
+ iZoneInfoSetDes().iEndPointZone.iId = iIfInfo.iRealNetId;
+
+ LOG(Log::Printf(_L("CVpnConnStarter::LoadIpsecPolicy - VPN NET ID=%d, Real NET ID=%d\n"),
+ iEventSpecDes().iIfInfo.iVpnNetId, iIfInfo.iRealNetId ));
+
+#if defined(__PFX_MIP4__)
+
+ if (IsMip4FeaturePresent())
+ {
+ LOG(Log::Printf(_L("CVpnConnStarter::LoadIpsecPolicy - MIPv4 present, adding MIPv4 bypass selectors\n")));
+ iProcessingFlags = KAddIkeBypassSelectors | KAddMip4BypassSelectors;
+ }
+ else
+ {
+ LOG(Log::Printf(_L("CVpnConnStarter::LoadIpsecPolicy - MIPv4 NOT present, NOT adding MIPv4 bypass selectors\n")));
+ iProcessingFlags = KAddIkeBypassSelectors;
+ }
+
+#else
+
+ LOG(Log::Printf(_L("CVpnConnStarter::LoadIpsecPolicy - MIPv4 NOT present, NOT adding MIPv4 bypass selectors\n")));
+ iProcessingFlags = KAddIkeBypassSelectors;
+
+#endif // __PFX_MIP4__
+
+ // Check from commdb wether "real" interface uses DHCP
+ // and if it does, KAddDhcpBypassSelectors is added to
+ // the processing flags
+
+ TBool dhcpEnabled = EFalse;
+ TRAPD(err, IsDhcpEnabledL(dhcpEnabled));
+
+ if (!err && dhcpEnabled)
+ {
+ iProcessingFlags |= KAddDhcpBypassSelectors;
+ }
+
+ iPolicyServ.LoadPolicy(*iIpsecPolicyData, iIpsecPolicyHandleDes,
+ iStatus, iZoneInfoSetDes, iProcessingFlags);
+ }
+
+void CVpnConnStarter::IsDhcpEnabledL(TBool& aDhcpEnabled)
+ {
+ using namespace CMManager;
+
+ RCmManagerExt cmManagerExt;
+ cmManagerExt.OpenL();
+ CleanupClosePushL(cmManagerExt);
+
+ RCmConnectionMethodExt connectionMethod = cmManagerExt.ConnectionMethodL( iIfInfo.iRealIapId );
+ CleanupClosePushL(connectionMethod);
+
+ aDhcpEnabled = connectionMethod.GetBoolAttributeL(ECmIPAddFromServer);
+ if (!aDhcpEnabled)
+ {
+ aDhcpEnabled = connectionMethod.GetBoolAttributeL(ECmIPDNSAddrFromServer);
+ }
+
+ CleanupStack::PopAndDestroy(2);
+ }
+
+#if defined(__PFX_MIP4__)
+
+TBool CVpnConnStarter::IsMip4FeaturePresent(void)
+ {
+ return FeatureManager::FeatureSupported(KFeatureIdMIPv4);
+ }
+
+#endif // __PFX_MIP4__