/*
* Copyright (c) 2008 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
*
*/


#include "ikedebug.h"
#include "ikeplugindefs.h"
#include "ikepluginif.h"
#include "ikepluginsessionhandler.h"
#include "kmdeventloggerif.h"

// CLASS HEADER
#include "ikepluginhandler.h"

_LIT( KIkePluginPaths, "" ); // No additional paths.
_LIT( KIkeV1Library, "ikev1lib" ); 
_LIT( KIkeV2Library, "ikev2lib" ); 

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

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CIkePluginHandler* CIkePluginHandler::NewL( TInt aIkeVersion,
                                            MKmdEventLoggerIf& aEventLogger,
                                            MIkeDebug& aDebug )
    {
    CIkePluginHandler* self = new ( ELeave ) CIkePluginHandler( aIkeVersion,
                                                                aEventLogger,
                                                                aDebug );
    return self;
    }
    
// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CIkePluginHandler::~CIkePluginHandler()
    {
    __ASSERT_DEBUG( iIkePluginSessions.Count() == 0,
                    User::Invariant() );
    iIkePluginSessions.Close();    
    }

// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
CIkePluginHandler::CIkePluginHandler( TInt aIkeVersion,
                                      MKmdEventLoggerIf& aEventLogger,
                                      MIkeDebug& aDebug ) 
 : iIkeVersion( aIkeVersion ),
   iEventLogger( aEventLogger ),
   iDebug( aDebug )
    {
    __ASSERT_DEBUG( ( iIkeVersion == KIkeV1 ||
                      iIkeVersion == KIkeV2 ),
                      User::Invariant() );
    }    

// ---------------------------------------------------------------------------
// Creates IKE plugin session.
// ---------------------------------------------------------------------------
//
CIkePluginSessionHandler& CIkePluginHandler::CreateIkePluginSessionL( TUint32 aVpnIapId,
                                                                      TUint32 aVpnNetId,
                                                                      TUint32 aVpnInterfaceIndex,
                                                                      IkeSocket::TIpVersion aIpVersion,
                                                                      const TInetAddr& aDnsServer,
                                                                      CIkeConnectionInterface& aConnection,
                                                                      MIkePluginSessionHandlerCallback& aCallback )            
    {
    CIkePluginSessionHandler* sessionHandler = NULL;    
    TRAPD( err, sessionHandler = &DoCreateIkePluginSessionL( aVpnIapId,
                                                             aVpnNetId,
                                                             aVpnInterfaceIndex,
                                                             aIpVersion,
                                                             aDnsServer,
                                                             aConnection,
                                                             aCallback ) );
    
    if ( err != KErrNone )
        {        
        DeleteIkePluginSession( aVpnIapId );
        User::Leave( err );
        }
    
    return *sessionHandler;
    }

// ---------------------------------------------------------------------------
// Deletes IKE plugin session. IKE plugin is unloaded if there are no more
// sessions.
// ---------------------------------------------------------------------------
//
void CIkePluginHandler::DeleteIkePluginSession( TUint32 aVpnIapId )
    {
    TInt count = iIkePluginSessions.Count();
    
    for ( TInt i=0; i<count; i++ )
        {
        if ( iIkePluginSessions[i]->VpnIapId() == aVpnIapId )
            {
            CIkePluginSessionHandler* sessionHandler = iIkePluginSessions[i];
            iIkePluginSessions.Remove( i );
            delete sessionHandler;
            sessionHandler = NULL;            
            break;
            }
        }
    
    if ( iIkePluginSessions.Count() == 0 )
        {
        UnloadIkePlugin();
        }
    }
	
// ---------------------------------------------------------------------------
// Creates IKE plugin session. IKE plugin is loaded if not yet loaded.
// ---------------------------------------------------------------------------
//
CIkePluginSessionHandler& CIkePluginHandler::DoCreateIkePluginSessionL( TUint32 aVpnIapId,
                                                                        TUint32 aVpnNetId,
                                                                        TUint32 aVpnInterfaceIndex,
                                                                        IkeSocket::TIpVersion aIpVersion,
                                                                        const TInetAddr& aDnsServerAddr,
                                                                        CIkeConnectionInterface& aConnection,
                                                                        MIkePluginSessionHandlerCallback& aCallback )            
    {
    if ( iIkePluginSessions.Count() == 0 )
        {
        LoadIkePluginL();
        }
    
    CIkePluginSessionHandler* sessionHandler = CIkePluginSessionHandler::NewLC( aVpnIapId,
                                                                                aVpnNetId,
                                                                                aVpnInterfaceIndex,
                                                                                IkeSocket::TIkeMajorVersion(iIkeVersion),
                                                                                aIpVersion,
                                                                                aDnsServerAddr,
                                                                                aConnection,
                                                                                *iIkePlugin,
                                                                                aCallback,
                                                                                iDebug );   
    iIkePluginSessions.AppendL( sessionHandler );
    CleanupStack::Pop( sessionHandler );
    
    return *sessionHandler;
    }

// ---------------------------------------------------------------------------
// Loads IKE plugin.
// ---------------------------------------------------------------------------
//
void CIkePluginHandler::LoadIkePluginL()
    {	
    TInt status( KErrNone );
        
    switch( iIkeVersion )
        {
        case KIkeV1:
            {
            TUidType uidType( KIkePluginUid1, KIkePluginUid2, KIkeV1PluginUid3 );
            status = iLibrary.Load( KIkeV1Library, KIkePluginPaths, uidType );            
            break;
            }
        case KIkeV2:
            {
            TUidType uidType( KIkePluginUid1, KIkePluginUid2, KIkeV2PluginUid3 );
            status = iLibrary.Load( KIkeV2Library, KIkePluginPaths, uidType );            
            break;            
            }
        default:
            {
            status = KErrNotSupported;
            break;
            }        
        }
    
    DEBUG_LOG2( _L("Loading IKE plugin library, IKE version=%d, status=%d"), iIkeVersion, status );    
    User::LeaveIfError( status );
    
    CreateIkePluginL factoryMethodL  = reinterpret_cast<CreateIkePluginL>( iLibrary.Lookup(1) );    
    TRAPD( err, ( iIkePlugin = factoryMethodL( iEventLogger, iDebug ) ) );
    if ( err != KErrNone )
        {
        DEBUG_LOG1( _L("Could not create IKE plugin, err=%d"), err );
        UnloadIkePlugin();
        User::Leave( err );
        }    
    }

// ---------------------------------------------------------------------------
// Unloads IKE plugin.
// ---------------------------------------------------------------------------
//
void CIkePluginHandler::UnloadIkePlugin()
    {
    DEBUG_LOG1( _L("Unloading IKE Plugin library, IKE version=%d"), iIkeVersion );
    delete iIkePlugin;
    iIkePlugin = NULL;
    iLibrary.Close();    
    }