/*
* 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:  Handler of an IKE protocol plugin session
*
*/


#include <in_sock.h>

#include "errorobserver.h"
#include "iachangeobserver.h"
#include "ikeconnectioninterface.h"
#include "ikedebug.h"
#include "ikepluginif.h"
#include "ikepluginsessionif.h"
#include "ikesocketdefs.h"
#include "internaladdress.h"

// CLASS HEADER
#include "ikepluginsessionhandler.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CIkePluginSessionHandler* CIkePluginSessionHandler::NewLC( TUint32 aVpnIapId,
                                                           TUint32 aVpnNetId,
                                                           TUint32 aVpnInterfaceIndex,
                                                           IkeSocket::TIkeMajorVersion aIkeVersion,
                                                           IkeSocket::TIpVersion aIpVersion,
                                                           const TInetAddr& aDnsServerAddr,
                                                           CIkeConnectionInterface& aConnection,
                                                           MIkePluginIf& aIkePlugin,            
                                                           MIkePluginSessionHandlerCallback& aCallback,
                                                           MIkeDebug& aDebug )
    {
    CIkePluginSessionHandler* self = new (ELeave) CIkePluginSessionHandler( aVpnIapId,
                                                                            aIkeVersion,
                                                                            aIpVersion,
                                                                            aCallback,
                                                                            aDebug );
    CleanupStack::PushL( self );
    self->ConstructL( aVpnNetId,
                      aVpnInterfaceIndex,
                      aDnsServerAddr,
                      aConnection,
                      aIkePlugin );
    return self;
    }
    
// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CIkePluginSessionHandler::~CIkePluginSessionHandler()
    {
    Cancel();

    delete iErrorObserver;
    delete iIaChangeObserver;
    delete iIkePluginSession;
    }

// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
CIkePluginSessionHandler::CIkePluginSessionHandler( TUint32 aVpnIapId,
                                                    IkeSocket::TIkeMajorVersion aIkeVersion,
                                                    IkeSocket::TIpVersion aIpVersion,
                                                    MIkePluginSessionHandlerCallback& aCallback,
                                                    MIkeDebug& aDebug ) 
 : CActive( EPriorityStandard ),
   iVpnIapId( aVpnIapId ),
   iIkeVersion( aIkeVersion ),
   iIpVersion( aIpVersion ),
   iCallback( aCallback ),
   iDebug( aDebug )
    {
    CActiveScheduler::Add( this );
    }    

// ---------------------------------------------------------------------------
// Second phase construction.
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::ConstructL( TUint32 aVpnNetId,
                                           TUint32 aVpnInterfaceIndex,
                                           const TInetAddr& aDnsServerAddr,
                                           CIkeConnectionInterface& aConnection,
                                           MIkePluginIf& aIkePlugin )
    {
    if ( iIkeDataInterface == NULL )
        {
        iIkeDataInterface = &aConnection.OpenDataInterfaceL( iIkeVersion,
                                                             iIpVersion );
        }    
    
    iIkePluginSession = aIkePlugin.CreateSessionL( iVpnIapId,
                                                   aVpnNetId,
                                                   aVpnInterfaceIndex,
                                                   *iIkeDataInterface );  
    
    iErrorObserver = CErrorObserver::NewL( *iIkePluginSession,
                                           iCallback,
                                           iDebug );
    
    iIaChangeObserver = CIaChangeObserver::NewL( iVpnIapId,
                                                 aDnsServerAddr,
                                                 *iIkePluginSession,
                                                 iDebug );
    
    DEBUG_LOG(_L("IKE plugin session created."));
    }       

// ---------------------------------------------------------------------------
// Starts negotiation with a remote host asynchronously.
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::NegotiateWithHost( const CIkeData& aIkeData )
    {
    __ASSERT_DEBUG( iState == EIdle,
                    User::Invariant() );
    iIkePluginSession->NegotiateWithHost( aIkeData,
                                          iInternalAddress,
                                          iStatus );
    SetActive();
    iState = ENegotiatingWithHost;
    }

// ---------------------------------------------------------------------------
// Cancels negotiation request.
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::CancelNegotiateWithHost()
    {
    if ( iState == ENegotiatingWithHost &&
         IsActive() )
        {
        Cancel();
        TVPNAddress empty;
        iCallback.NegotiationStarted( KErrCancel,
                                      empty );
        }
    }

// ---------------------------------------------------------------------------
// Deletes session. 
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::DeleteSession( TBool aSilentClose )
    {
    iErrorObserver->Cancel();
    iIaChangeObserver->Cancel();
    
    if ( iState == ENegotiated )
        {
        // Delete session asynchronously.
        iIkePluginSession->DeleteSession( aSilentClose, iStatus );
        SetActive();
        iState = EDeletingSession;
        }
    else if ( iState == EDeletingSession )
        {
        // Session deletion is already in progress. Cancelling it deletes
        // session silently.
        CancelDeleteSession();
        }
    else if ( iState == EIdle )
        {
        // Session deletion can be requested, if negotiate request has failed.
        // In this case, it is enough to complete request.
        TRequestStatus* ownStatus = &iStatus;
        *ownStatus = KRequestPending;
        SetActive();
                
        User::RequestComplete( ownStatus, KErrNone );
        }
    else
        {
        ASSERT( EFalse );
        }
    }

// ---------------------------------------------------------------------------
// Cancels session deletion request.
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::CancelDeleteSession()
    {
    if ( IsActive() )
        {
        Cancel();
        iCallback.IkePluginSessionClosed( KErrCancel );
        }
    }

// ---------------------------------------------------------------------------
// Returns VPN IAP Id.
// ---------------------------------------------------------------------------
//
TInt CIkePluginSessionHandler::VpnIapId() const
    {
    return iVpnIapId;
    }

// ---------------------------------------------------------------------------
// From class CActive
// Handles completion of asynchronous request. 
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::RunL()
    {
    DEBUG_LOG2( _L("CIkePluginSessionHandler::RunL, iState=%d, iStatus=%d"),
            iState, iStatus.Int() );

    switch ( iState )
        {
        case ENegotiatingWithHost:
            if ( iStatus.Int() == KErrNone )
                {
                iErrorObserver->StartObserving();
                iIaChangeObserver->StartObserving();
                iState = ENegotiated;
                }
            else
                {
                iState = EIdle;
                }
            // Ownership of internal address transferred.
            iCallback.NegotiationStarted( iStatus.Int(),
                                          iInternalAddress );
            break;
        case EDeletingSession: // Fall through
        case EIdle:        
            iState = EIdle;
            iCallback.IkePluginSessionClosed( iStatus.Int() );
            break;
        default:           
            ASSERT( EFalse );
            break;
        }        
    }

// ---------------------------------------------------------------------------
// From class CActive
// Handles cancellation of asynchronous request. 
// ---------------------------------------------------------------------------
//
void CIkePluginSessionHandler::DoCancel()
    {
    DEBUG_LOG1( _L("CIkePluginSessionHandler::DoCancel, iState=%d"),
            iState );

    switch ( iState )
        {
        case ENegotiatingWithHost: 
            iIkePluginSession->CancelNegotiateWithHost();
            iInternalAddress = TVPNAddress();
            // Session deletion is needed later, if negotiate request has
            // already been completed from IKE plugin session.            
            iState = ENegotiated;           
            break;
        case EDeletingSession:
            iIkePluginSession->CancelDeleteSession();
            iState = EIdle;
            break;
        case EIdle:                                    
            break;
        default:
            ASSERT( EFalse );
            break;
        }    
    }