/*

* 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:  KMD server

*

*/

// INTERNAL INCLUDES

#include "ikedebug.h"

#include "ikeplugindefs.h"

#include "ikepluginhandler.h"

#include "kmddebuglogger.h"

#include "kmdeventlogger.h"

#include "kmdsession.h"

#include "secpolreader.h"

#include "vpnconnection.h"

// CLASS HEADER

#include "kmdserver.h"

const TUint CKmdServer::iKmdServerRangeCount = 2;

const TInt CKmdServer::iKmdServerRanges[iKmdServerRangeCount] = 

    {

    CKmdServer::KKmdStartConnection,

    CKmdServer::KKmdCancelResolveAddress+1

    };

const TUint8 CKmdServer::iKmdServerElementIndex[iKmdServerRangeCount] = 

    {

    0,

    CPolicyServer::ENotSupported

    };

const CPolicyServer::TPolicyElement CKmdServer::iKmdServerElements[] =

    {

    {_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl), 

      CPolicyServer::EFailClient},

    };

const CPolicyServer::TPolicy CKmdServer::iKmdServerPolicy =

    {

    0,                      // All connect attempts are checked

    iKmdServerRangeCount,   // Count of ranges

    iKmdServerRanges,       // 0-6, 7...

    iKmdServerElementIndex, // Only range 0-6 are checked

    iKmdServerElements      // The list of policy elements

    };

const TInt KIkeV1PluginHandlerIndex( 0 );

const TInt KIkeV2PluginHandlerIndex( 1 );

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

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CKmdServer* CKmdServer::NewL()

    {

    CKmdServer* self = new ( ELeave ) CKmdServer;

    CleanupStack::PushL( self );

    self->ConstructL();    

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor.

// ---------------------------------------------------------------------------

//

CKmdServer::~CKmdServer()

    {    

    iIpsecPolicyServ.Close();

    iVpnConnections.ResetAndDestroy();

    iVpnConnections.Close();    

    delete iIkePluginHandlers[0];

    delete iIkePluginHandlers[1];

    delete iSecpolReader;

    delete iEventLogger;

#ifdef _DEBUG

    if ( iDebugLogger != NULL )

        {

        iDebugLogger->LogWrite(_L("KMD server stopped."));

        }

#endif        

    delete iDebugLogger;

    }

// ---------------------------------------------------------------------------

// Constructor.

// ---------------------------------------------------------------------------

//

CKmdServer::CKmdServer() : 

 CPolicyServer( EPriorityStandard, iKmdServerPolicy )

    {

    }

// ---------------------------------------------------------------------------

// Second phase construction.

// ---------------------------------------------------------------------------

//

void CKmdServer::ConstructL()

    {

    iDebugLogger = CKmdDebugLogger::NewL();

#ifdef _DEBUG

    iDebugLogger->LogWrite(_L("------------------------------------------------------"));

    iDebugLogger->LogWrite(_L("Starting KMD server."));

    iDebugLogger->LogWrite(_L("------------------------------------------------------"));

#endif    

    User::LeaveIfError( iIpsecPolicyServ.Connect() );        

    iEventLogger = CKmdEventLogger::NewL( *iDebugLogger );

    iSecpolReader = CSecpolReader::NewL( *iEventLogger,

                                         *iDebugLogger );

    iIkePluginHandlers[KIkeV1PluginHandlerIndex] = CIkePluginHandler::NewL( KIkeV1,

                                                                            *iEventLogger,

                                                                            *iDebugLogger );

    iIkePluginHandlers[KIkeV2PluginHandlerIndex] = CIkePluginHandler::NewL( KIkeV2,

                                                                            *iEventLogger,

                                                                            *iDebugLogger );

    StartL( KKmdServerName );

#ifdef _DEBUG

    iDebugLogger->LogWrite(_L("KMD server started."));

#endif        

    }

// ---------------------------------------------------------------------------

// Information that KMD session has been closed.

// ---------------------------------------------------------------------------

//

void CKmdServer::KmdSessionClosed()

    {

    iSessionCount--;    

    __ASSERT_DEBUG(iSessionCount >= 0, User::Invariant());

    StopKmdServer();

    }

// ---------------------------------------------------------------------------

// Creates VPN connection object.

// ---------------------------------------------------------------------------

//

CVpnConnection& CKmdServer::CreateVpnConnectionL(TUint32 aVpnIapId)

    {

#ifndef _DEBUG

    for ( TInt i = 0; i < iVpnConnections.Count(); ++i )

        {

        __ASSERT_DEBUG( iVpnConnections[i]->VpnIapId() != aVpnIapId, User::Invariant() );

        }

#endif //_DEBUG    

    CVpnConnection* newConnection = CVpnConnection::NewLC( aVpnIapId,

                                                           *this,

                                                           *iDebugLogger );

    User::LeaveIfError( iVpnConnections.Append( newConnection ) );

    CleanupStack::Pop( newConnection );

    return *newConnection;        

    }

// ---------------------------------------------------------------------------

// Gets VPN connection object.

// ---------------------------------------------------------------------------

//

CVpnConnection& CKmdServer::GetVpnConnectionL( TUint32 aVpnIapId )

    {

    CVpnConnection* connection = NULL;

    for ( TInt i = 0; i < iVpnConnections.Count(); ++i )

        {

        CVpnConnection* c = iVpnConnections[i];

        if ( c->VpnIapId() == aVpnIapId )

            {

            connection = c;

            break;

            }

        }

    if ( connection == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *connection;            

    }

// ---------------------------------------------------------------------------

// Deletes VPN connection object.

// ---------------------------------------------------------------------------

//

void CKmdServer::DeleteVpnConnection( TUint32 aVpnIapId )

    {    

    TInt connectionCount = iVpnConnections.Count();

    for ( TInt i = 0; i < connectionCount; ++i )

        {

        CVpnConnection* c = iVpnConnections[i];

        if ( c->VpnIapId() == aVpnIapId )

            {

            iVpnConnections.Remove( i );

            delete c;

            break;

            }

        }

    StopKmdServer();

    }

// ---------------------------------------------------------------------------

// Creates IKE plugin session.

// ---------------------------------------------------------------------------

//

CIkePluginSessionHandler& CKmdServer::CreateIkePluginSessionL( TInt aIkeVersion,

                                                               IkeSocket::TIpVersion aIpVersion,

                                                               CIkeConnectionInterface& aConnection,

                                                               TUint32 aVpnIapId,

                                                               TUint32 aVpnNetId,

                                                               TUint32 aVpnInterfaceIndex,

                                                               const TInetAddr& aDnsServerAddr,

                                                               MIkePluginSessionHandlerCallback& aCallback )

    {

    TInt index( 0 );

    switch ( aIkeVersion )

        {

        case KIkeV1:

            {

            index = KIkeV1PluginHandlerIndex;

            break;

            }

        case KIkeV2:

            {

            index = KIkeV2PluginHandlerIndex;

            break;

            }

        default:

            {

            ASSERT( EFalse );

            }        

        }

    return iIkePluginHandlers[index]->CreateIkePluginSessionL( aVpnIapId,

                                                               aVpnNetId,

                                                               aVpnInterfaceIndex,

                                                               aIpVersion,

                                                               aDnsServerAddr,

                                                               aConnection,

                                                               aCallback );

    }

// ---------------------------------------------------------------------------

// Deletes IKE plugin session.

// ---------------------------------------------------------------------------

//

void CKmdServer::DeleteIkePluginSession( TInt aIkeVersion,

                                         TUint32 aVpnIapId )

    {

    TInt index( 0 );

    switch ( aIkeVersion )

        {

        case KIkeV1:

            {

            index = KIkeV1PluginHandlerIndex;

            break;

            }

        case KIkeV2:

            {

            index = KIkeV2PluginHandlerIndex;

            break;

            }

        default:

            {

            ASSERT( EFalse );

            break;

            }        

        }

    iIkePluginHandlers[index]->DeleteIkePluginSession( aVpnIapId );

    }

// ---------------------------------------------------------------------------

// Returns debug trace interface.

// ---------------------------------------------------------------------------

//

MIkeDebug& CKmdServer::Debug()

    {

    __ASSERT_DEBUG( iDebugLogger != NULL,

                    User::Invariant() );

    return *iDebugLogger;

    }

// ---------------------------------------------------------------------------

// Creates a server-side session object.

// ---------------------------------------------------------------------------

//

CSession2* CKmdServer::NewSessionL( const TVersion& /*aVersion*/,

                                    const RMessage2& /*aMessage*/) const

    {

    CKmdSession* session = CKmdSession::NewL( *const_cast<CKmdServer*>( this ),

                                              *iDebugLogger );

    iSessionCount++;

    return session;

    }

// ---------------------------------------------------------------------------

// Stops KMD server if there exist neither client sessions nor active

// connections.

// ---------------------------------------------------------------------------

//

void CKmdServer::StopKmdServer()

    {

    if ( iSessionCount == 0 &&

         iVpnConnections.Count() == 0 )   

        {

        // Stop scheduluder that was started by RunServerL().

        CActiveScheduler::Stop();        

        }

    }