/*
* Copyright (c) 2008-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 specific structures
*
*/
#include <cmmanagerext.h>
#include <cmpluginvpndef.h>
#include "disconnectionobserver.h"
#include "ikeconnectioninterface.h"
#include "ikedebug.h"
#include "ikeplugindefs.h"
#include "ikepluginsessionhandler.h"
#include "ikepolparser.h"
#include "ikesocketdefs.h"
#include "kmdapi.h" // For error codes
#include "kmdserver.h"
// CLASS HEADER
#include "vpnconnection.h"
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CVpnConnection* CVpnConnection::NewLC( TUint32 aVpnIapId,
CKmdServer& aServer,
MIkeDebug& aDebug )
{
CVpnConnection* self = new ( ELeave ) CVpnConnection( aVpnIapId,
aServer,
aDebug );
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CVpnConnection::~CVpnConnection()
{
DEBUG_LOG1( _L("CVpnConnection::~CVpnConnection, VPN IAP id=%d"),
iVpnIapId );
delete iDisconnectionObserver;
delete iIkeConnection;
iEventMediator.Close();
}
// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
CVpnConnection::CVpnConnection( TUint32 aVpnIapId,
CKmdServer& aServer,
MIkeDebug& aDebug )
: iServer( aServer ),
iVpnIapId( aVpnIapId ),
iDisconnectEventReceived( EFalse ),
iIkePluginSessionHandler( NULL ),
iDebug( aDebug )
{
DEBUG_LOG1( _L("CVpnConnection::CVpnConnection, VPN IAP id=%d"),
iVpnIapId );
}
// ---------------------------------------------------------------------------
// Second phase construction.
// ---------------------------------------------------------------------------
//
void CVpnConnection::ConstructL()
{
User::LeaveIfError( iEventMediator.Connect() );
using namespace CMManager;
RCmManagerExt cmManagerExt;
cmManagerExt.OpenL();
CleanupClosePushL( cmManagerExt );
RCmConnectionMethodExt vpnConnectionMethod = cmManagerExt.ConnectionMethodL( iVpnIapId );
CleanupClosePushL( vpnConnectionMethod );
iVpnNetId = vpnConnectionMethod.GetIntAttributeL( ECmNetworkId );
iRealIapId = vpnConnectionMethod.GetIntAttributeL( EVpnIapId );
iRealSnapId = vpnConnectionMethod.GetIntAttributeL( ECmNextLayerSNAPId );
CleanupStack::PopAndDestroy( &vpnConnectionMethod );
CleanupStack::PopAndDestroy( &cmManagerExt );
__ASSERT_DEBUG( iRealIapId != 0 || iRealSnapId != 0, User::Invariant() );
iIkeConnection = CIkeConnectionInterface::NewL( iDebug );
iDisconnectionObserver = CDisconnectionObserver::NewL( *iIkeConnection, *this );
iDisconnectionObserver->StartObserving();
}
// ---------------------------------------------------------------------------
// Starts real network connection.
// ---------------------------------------------------------------------------
//
void CVpnConnection::StartRealConnection( TRequestStatus& aStatus )
{
__ASSERT_DEBUG( iRealIapId != 0 || iRealSnapId != 0, User::Invariant() );
iIkeConnection->StartConnection( iRealIapId, iRealSnapId, aStatus );
}
// ---------------------------------------------------------------------------
// Cancels real connection starting.
// ---------------------------------------------------------------------------
//
void CVpnConnection::CancelStartRealConnection()
{
iIkeConnection->CancelStartConnection();
}
// ---------------------------------------------------------------------------
// Resolves an IP address from FQDN address.
// ---------------------------------------------------------------------------
//
void CVpnConnection::ResolveAddress( const TDesC& aFqdn,
TNameEntry& aNameEntry,
TRequestStatus& aStatus )
{
iIkeConnection->ResolveFQDNAddress( aFqdn, aNameEntry, aStatus );
}
// ---------------------------------------------------------------------------
// Cancels resolving.
// ---------------------------------------------------------------------------
//
void CVpnConnection::CancelResolveAddress()
{
iIkeConnection->CancelResolveFQDNAddress();
}
// ---------------------------------------------------------------------------
// Starts negotiation with a remote host.
// ---------------------------------------------------------------------------
//
void CVpnConnection::NegotiateWithHost( CIkeData& aIkeData,
TUint32 aVpnInterfaceIndex,
IkeSocket::TIpVersion aIpVersion,
TVPNAddress& aInternalAddress,
TRequestStatus& aStatus )
{
__ASSERT_DEBUG( iClientStatusNegotiate == NULL,
User::Invariant() );
// Store client's request status and internal address.
iClientStatusNegotiate = &aStatus;
*iClientStatusNegotiate = KRequestPending;
iClientInternalAddress = &aInternalAddress;
TInt err( KErrNone );
if ( aIkeData.iIkeVersion == KIkeV1 || aIkeData.iIkeVersion == KIkeV2 )
{
// Create IKE plugin session.
iIkeVersion = aIkeData.iIkeVersion;
if ( iIkePluginSessionHandler == NULL )
{
TRAP( err, iIkePluginSessionHandler = &iServer.CreateIkePluginSessionL( iIkeVersion,
aIpVersion,
*iIkeConnection,
iVpnIapId,
iVpnNetId,
aVpnInterfaceIndex,
aIkeData.iDnsServer.Address(),
*this ) );
}
}
else
{
err = KKmdIkePolicyFileErr;
}
if ( err != KErrNone )
{
User::RequestComplete( iClientStatusNegotiate, err );
iClientStatusNegotiate = NULL;
return;
}
if ( aIkeData.iAddr.Family() == KAfInet )
{
aIkeData.iAddr.ConvertToV4Mapped();
aIkeData.iMask.ConvertToV4Mapped();
}
aIkeData.iAddr.SetScope( RealNetId() );
// Start negotiation.
iIkePluginSessionHandler->NegotiateWithHost( aIkeData );
}
// ---------------------------------------------------------------------------
// Cancels negotiation.
// ---------------------------------------------------------------------------
//
void CVpnConnection::CancelNegotiateWithHost()
{
DoCancelNegotiateWithHost();
}
// ---------------------------------------------------------------------------
// Stops VPN connection.
// ---------------------------------------------------------------------------
//
void CVpnConnection::StopVpnConnection( TBool aSilentClose,
TRequestStatus& aStatus )
{
__ASSERT_DEBUG( iClientStatusStopVpnConnection == NULL,
User::Invariant() );
// Store client's request status.
iClientStatusStopVpnConnection = &aStatus;
*iClientStatusStopVpnConnection = KRequestPending;
DoStopVpnConnection( aSilentClose );
}
// ---------------------------------------------------------------------------
// Cancels VPN connection stoppping. VPN Connection is stopped silently.
// ---------------------------------------------------------------------------
//
void CVpnConnection::CancelStopVpnConnection()
{
DoCancelStopVpnConnection();
}
// ---------------------------------------------------------------------------
// Gets local address of real network interface.
// ---------------------------------------------------------------------------
//
TInt CVpnConnection::GetLocalAddress( const IkeSocket::TIpVersion aIpVersion,
TInetAddr& aLocalIp )
{
return iIkeConnection->GetLocalAddress( aIpVersion, aLocalIp );
}
// ---------------------------------------------------------------------------
// Returns VPN IAP Id.
// ---------------------------------------------------------------------------
//
TInt CVpnConnection::VpnIapId() const
{
return iVpnIapId;
}
// ---------------------------------------------------------------------------
// Returns real IAP Id.
// ---------------------------------------------------------------------------
//
TInt CVpnConnection::RealIapId() const
{
return iIkeConnection->IapId();
}
// ---------------------------------------------------------------------------
// Returns real NET Id.
// ---------------------------------------------------------------------------
//
TInt CVpnConnection::RealNetId() const
{
return iIkeConnection->NetId();
}
// ---------------------------------------------------------------------------
// From class MDisconnectionObserverCallback.
// Notification about link disconnection. VPN connection is stopped.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DisconnectIndication( TInt aStatus )
{
// Store disconnection status for reporting it to client.
iDisconnectEventReceived = ETrue;
iDisconnectionStatus = aStatus;
DEBUG_LOG1( _L("Link disconnected, status=%d"),
iDisconnectionStatus );
if ( iDisconnectionStatus == KErrNone )
{
iDisconnectionStatus = KErrDisconnected;
}
// Stop VPN connection silently.
DoStopVpnConnection( ETrue );
}
// ---------------------------------------------------------------------------
// From class MIkePluginSessionHandlerCallback.
// Notification about completion of negotiate request.
// ---------------------------------------------------------------------------
//
void CVpnConnection::NegotiationStarted( TInt aStatus,
const TVPNAddress& aInternalAddress )
{
__ASSERT_DEBUG( iIkePluginSessionHandler != NULL,
User::Invariant() );
DEBUG_LOG1( _L("NegotiateWithHost completed, status=%d"),
aStatus );
// Use disconnection status for reporting if set.
if ( iDisconnectEventReceived )
{
aStatus = iDisconnectionStatus;
}
if ( iClientStatusNegotiate != NULL )
{
*iClientInternalAddress = aInternalAddress;
// Complete client's request.
User::RequestComplete( iClientStatusNegotiate, aStatus );
iClientInternalAddress = NULL;
iClientStatusNegotiate = NULL;
}
}
// ---------------------------------------------------------------------------
// From class MIkePluginSessionHandlerCallback.
// Notification about completion of delete session request. IKE plugin
// session object is deleted and real connection stopped.
// ---------------------------------------------------------------------------
//
void CVpnConnection::IkePluginSessionClosed( TInt aStatus )
{
__ASSERT_DEBUG( iIkePluginSessionHandler != NULL,
User::Invariant() );
DEBUG_LOG1( _L("IKE plugin session closed, status=%d"),
aStatus );
iServer.DeleteIkePluginSession( iIkeVersion, iVpnIapId );
iIkePluginSessionHandler = NULL;
DoStopRealConnection( aStatus );
}
// ---------------------------------------------------------------------------
// From class MIkePluginSessionHandlerCallback.
// Notification about IKE plugin session error.
// ---------------------------------------------------------------------------
//
void CVpnConnection::IkePluginSessionError( TInt aStatus )
{
// Stop VPN connection silently.
DisconnectIndication( aStatus );
}
// ---------------------------------------------------------------------------
// Cancels negotiation.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoCancelNegotiateWithHost()
{
if ( iIkePluginSessionHandler )
{
iIkePluginSessionHandler->CancelNegotiateWithHost();
}
}
// ---------------------------------------------------------------------------
// Stops VPN connection.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoStopVpnConnection( TBool aSilentClose )
{
if ( iIkePluginSessionHandler == NULL )
{
// Stop real connection immediately.
DoStopRealConnection( KErrNone );
}
else
{
DoCancelNegotiateWithHost();
// Delete IKE plugin session first.
DoDeleteSession( aSilentClose );
}
}
// ---------------------------------------------------------------------------
// Cancels VPN connection stopping. VPN Connection is stopped silently.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoCancelStopVpnConnection()
{
DoCancelDeleteSession();
if ( iIkePluginSessionHandler != NULL )
{
iServer.DeleteIkePluginSession( iIkeVersion, iVpnIapId );
iIkePluginSessionHandler = NULL;
}
DoStopRealConnection( KErrCancel );
}
// ---------------------------------------------------------------------------
// Starts deletion of IKE plugin session.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoDeleteSession( TBool aSilentClose )
{
__ASSERT_DEBUG( iIkePluginSessionHandler != NULL,
User::Invariant() );
iIkePluginSessionHandler->DeleteSession( aSilentClose );
}
// ---------------------------------------------------------------------------
// Cancels deletion of IKE plugin session. IKE plugin session is deleted
// silently.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoCancelDeleteSession()
{
if ( iIkePluginSessionHandler != NULL )
{
iIkePluginSessionHandler->CancelDeleteSession();
}
}
// ---------------------------------------------------------------------------
// Stops real network connection.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoStopRealConnection( TInt aStatus )
{
iDisconnectionObserver->Cancel();
iIkeConnection->StopConnection();
// Use disconnection status for reporting if set.
if ( iDisconnectEventReceived )
{
aStatus = iDisconnectionStatus;
}
if ( iClientStatusStopVpnConnection )
{
// Complete client's request.
User::RequestComplete( iClientStatusStopVpnConnection, aStatus );
iClientStatusStopVpnConnection = NULL;
}
DoReportDisconnectEvent( aStatus );
// Delete VPN connection object.
iServer.DeleteVpnConnection( iVpnIapId );
}
// ---------------------------------------------------------------------------
// Reports disconnect event via Event Mediator API.
// ---------------------------------------------------------------------------
//
void CVpnConnection::DoReportDisconnectEvent( TInt aStatus )
{
TPckg<TUint32> connInfoDes( iVpnIapId );
TEventData info;
info.iTaskStatus = aStatus;
TPckg<TEventData> infoDes( info );
DEBUG_LOG2( _L("Report disconnect event via event mediator, VPN IAP Id=%d, status=%d"),
iVpnIapId, aStatus );
iEventMediator.ReportEvent( EKmdRealIapConnDownEvent,
connInfoDes,
infoDes );
}