/*
* 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 );    
    }