/*

* Copyright (c) 2000-2010 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 Agent

*

*/

#include <cmmanager.h>

#include <cmconnectionmethod.h>

#include <cmpluginvpndef.h>

#include <commdbconnpref.h>

#include <in_iface.h>

#include <tunnelnifvar.h>

#include <d32dbmsconstants.h>

#include <featmgr.h>

#include "vpnconnagt.h"

#include "vpnsipobserver.h"

/***************CVPNConnAgtFactory********************/

extern "C" EXPORT_C CNifAgentFactory* NewAgentFactoryL()

    {   

    return new(ELeave) CVPNConnAgtFactory;

    }

void CVPNConnAgtFactory::InstallL() 

    {

    }

CNifAgentBase* CVPNConnAgtFactory::NewAgentL(

    const TDesC& /*aName*/)

    {

    return CVPNConnAgt::NewL();

    }

TInt CVPNConnAgtFactory::Info(

    TNifAgentInfo&  aInfo, 

    TInt            /*aIndex*/) const

    {

    aInfo.iName = KVPNConnAgtName;

    aInfo.iVersion = TVersion(KMajorVerNumber,KMinorVerNumber,KBuildVerNumber);

    return KErrNone;

    }

/***************CVPNConnAgt********************/

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

// CVPNConnAgt 

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

//

CVPNConnAgt::CVPNConnAgt() :

    iServiceStartedCallback(CActive::EPriorityStandard),

    iConnectCompleteCallback(CActive::EPriorityStandard), 

    iDisconnectCallback(CActive::EPriorityStandard)

    {

    TCallBack serviceStartedCallback(ServiceStartedCb, this);

    iServiceStartedCallback.Set(serviceStartedCallback);

    TCallBack connectionCompleteCallback(ConnectCompleteCb, this);

    iConnectCompleteCallback.Set(connectionCompleteCallback);

    TCallBack disconnectionCompleteCallback(DisconnectCompleteCb, this);

    iDisconnectCallback.Set(disconnectionCompleteCallback);

    iEventActivatedClose = EFalse;

    iDisconnectType = (TDeactivateType)NORMAL_DISCONNECT_MODE; // means the normal way to shutdown

    iFeatureManagerInitialized = EFalse;

    }

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

// Destructor 

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

//

CVPNConnAgt::~CVPNConnAgt()

    {

    LOG(TName name;

    name.AppendFormat(_L("[0x%08x]"), this);

    Log::Printf(_L("%s Destructing VPN Connection Agent\n"),name.PtrZ()));

    if ( FeatureManager::FeatureSupported( KFeatureIdFfImsDeregistrationInVpn ) )

        {

        delete iSipObserver;

        iSipObserver = NULL;

        }

    if ( iFeatureManagerInitialized )

        {

        // We can safely call UnInitializeLib as we have really intialized it.

        FeatureManager::UnInitializeLib();  // Decreases ref.count

        }

    iEventMediator.Close();

    iServiceStartedCallback.Cancel();

    iConnectCompleteCallback.Cancel();

    iDisconnectCallback.Cancel();

    }

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

// NewL() 

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

//

CVPNConnAgt* CVPNConnAgt::NewL()

    {

    CVPNConnAgt* self = new (ELeave) CVPNConnAgt();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// ConstructL() 

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

//

inline void CVPNConnAgt::ConstructL()

    {

    LOG_1("[0x%08x] Constructing VPN Connection Agent\n", this);

    // construct the database and dialog processor

    CAgentBase::ConstructL();

    iConnected = EFalse;

    iDisconnecting = EFalse;

    LOG_("CVPNConnAgt::ReadConfigurationL EventMediator");

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

    // Initialize Feature Manager.

    FeatureManager::InitializeLibL();  // Successfull call increases reference count

    iFeatureManagerInitialized = ETrue;

    // Create CVpnSipObserver for communicating with SIP profile server via 

    // P&S keys for SIP de/re-registration. this pointer is passed to have call back.

    if ( FeatureManager::FeatureSupported( KFeatureIdFfImsDeregistrationInVpn ) )

        {

        iSipObserver = CVpnSipObserver::NewL( *this );

        }

    }

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

// Info() 

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

//

void CVPNConnAgt::Info(

    TNifAgentInfo& aInfo) const

    {

    aInfo.iName = KVPNConnAgtName;

    aInfo.iName.AppendFormat(_L("-AgentFactory[0x%08x]"), this);

    aInfo.iVersion = TVersion(

        TCommDbConnPref::KMajorVersionNumber,

        TCommDbConnPref::KMinorVersionNumber,

        TCommDbConnPref::KBuildVersionNumber

    );

    }

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

// Connect() 

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

//

void CVPNConnAgt::Connect(

    TAgentConnectType /*aType*/)

    {

    iServiceStartedCallback.CallBack();

    }

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

// Connect() 

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

//

void CVPNConnAgt::Connect(

    TAgentConnectType   aType, 

    CStoreableOverrideSettings* /*aOverrideSettings*/)

    {

    Connect(aType);

    }

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

// CancelConnect() 

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

//

void CVPNConnAgt::CancelConnect()

    {

    LOG_("CVPNConnAgt::CancelConnect");

    iServiceStartedCallback.Cancel();

    iConnectCompleteCallback.Cancel();

    }

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

// Disconnect() 

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

//

void CVPNConnAgt::Disconnect(

    TInt aReason)

    {

    LOG_1("Disconnect called from Nifman with reason:%d\n", aReason);

    if ( iDisconnecting )

        {

        LOG_("Already disconnecting, return\n");

        return;

        }

    if ( aReason == KErrConnectionTerminated )

        iDisconnectType = (TDeactivateType)SILENT_DISCONNECT_MODE;

    iLastErrorCode = aReason;

    iDisconnectCallback.CallBack();

    }

/****************************************************************************/

/* GetExcessData()                                                          */

/****************************************************************************/

TInt CVPNConnAgt::GetExcessData(

    TDes8& /*aBuffer*/)

    {

    return KErrNotSupported;

    }

/****************************************************************************/

/* Notification()                                                           */

/* Nif calls this via agentref to pass the name of the nif.                 */

/****************************************************************************/

TInt CVPNConnAgt::Notification(

    TNifToAgentEventType aEvent,

    TAny* aInfo)

    {

    if ( (TTunnelNifToAgentEventType)aEvent == ENifToAgentEventTypeSetIfName )

        {

        iVPNParameters.SetVPNNifName(*(TName*)aInfo);

        return KErrNone;

        }

    if ( aEvent == ENifToAgentEventTypeLinkLayerDown )

        {// Tunnelnif down

        return KErrNone;

        }

    return KErrNotSupported;

    }

/****************************************************************************/

/* GetLastError()                                                           */

/****************************************************************************/

void CVPNConnAgt::GetLastError(TInt& aError)

    {

    aError = iLastErrorCode;

    }

TInt CVPNConnAgt::IncomingConnectionReceived()

    {

    return KErrNotSupported;

    }

/****************************************************************************/

/* ServiceStartedCb()                                                       */

/****************************************************************************/

TInt CVPNConnAgt::ServiceStartedCb(TAny* aThisPtr)

    {

    CVPNConnAgt* self = (CVPNConnAgt*)aThisPtr;

    TInt err = KErrNone;

    self->ServiceStarted(err);

    return err;

    }

/****************************************************************************/

/* ConnectCompleteCb()                                                      */

/****************************************************************************/

TInt CVPNConnAgt::ConnectCompleteCb(

    TAny* aThisPtr)

    {

    CVPNConnAgt* self = (CVPNConnAgt*) aThisPtr;

    self->ConnectionComplete(KErrNone);

    return KErrNone;

    }

/****************************************************************************/

/* DisconnectCompleteCb()                                                   */

/****************************************************************************/

TInt CVPNConnAgt::DisconnectCompleteCb(

    TAny* aThisPtr)

    {

    CVPNConnAgt* self = (CVPNConnAgt*) aThisPtr;

    self->DisconnectionComplete();

    return KErrNone;

    }

/****************************************************************************/

/* ServiceStarted()                                                         */

/****************************************************************************/

void CVPNConnAgt::ServiceStarted(TInt& aError)

    {

    iLastErrorCode = KErrNone;

    iNotify->AgentProgress(EVPNConnAgtConnecting, iLastErrorCode);

    // read IAP configuration

    TRAP(iLastErrorCode, ReadConfigurationL());

    if ( iLastErrorCode )

        {

        LOG(TName name;

        name.AppendFormat(_L("[0x%08x]"), this);

        Log::Printf(_L("%s Error %d in reading configuration\n"),name.PtrZ(), iLastErrorCode));

        iNotify->ConnectComplete(iLastErrorCode);

        aError = iLastErrorCode;

        return;

        }

    // SIP is deregistered before starting a VPN session. First tell SIP profile server to 

    // perform deregistration.  And when it's completed, continue VPN session start.

    // Note: A wait note is not used here for holding VPN session starting process because 

    // CInternetConnectionManager is showing one.

    // Tell SIP Profile Server to perform deregistration before proceeding VPN start.

    // Multiple VPN connection use cases are handled in SIP side.  VPN just notifies SIP

    // a VPN session is about to start.

    if ( FeatureManager::FeatureSupported( KFeatureIdFfImsDeregistrationInVpn ) )

        {

        // For some reason, if the request fails, just proceeds.

        if ( iSipObserver->RequestDeregister() != KErrNone )

            {

            ProceedServiceStart();

            }

        // Return for now. ProceedServiceStart() will be called later by iSipObserver when

        // deregistration process has been completed. Then VPN start process will be actually

        // initiated.

        return;

        }

    // If KFeatureIdFfImsDeregistrationInVpn is disabled, no SIP deregisration is performed.

    else

        {

        ProceedServiceStart();

        }

    }

/****************************************************************************/

/* ProceedServiceStart()                                                    */

/* Proceed VPN session start process                                        */

/****************************************************************************/

void CVPNConnAgt::ProceedServiceStart()

    {

    LOG_1("[0x%08x] Get protocol version\n", this);

    iProtocolVersionDes().iId = iEventMediator.NewEventSpecId();

    iProtocolVersionDes().iPolicyId = *(iVPNParameters.GetVPNPolicy());

    iEventMediator.ListenToEvent(

        EGetProtocolVersionEvent, iProtocolVersionDes, *this);

    iState = EGettingProtocolVersion;

    }

/****************************************************************************/

/* ConnectionComplete()                                                     */

/****************************************************************************/

void CVPNConnAgt::ConnectionComplete(

    TInt aError)

    {

    if ( aError )

        {

        switch ( iState )

            {

            case EGettingProtocolVersion:

                iEventMediator.CancelListening(EGetProtocolVersionEvent, iProtocolVersionDes);

                iNotify->AgentProgress(EVPNConnAgtDisconnected, aError);

                iNotify->ConnectComplete(aError);

                iState = EConnectionClosed;

                return;

            case EConnecting:

                iEventMediator.CancelListening(EStartVpnConnEvent, iStartVpnConnDes);

                iNotify->AgentProgress(EVPNConnAgtDisconnected, aError);

                iNotify->ConnectComplete(aError);

                iState = EConnectionClosed;

                return;

            default:

                break;

            }

        return;

        }

    TInetIfConfig addr;

    addr.iAddress = iVPNParameters.GetVPNNifAddress();

    addr.iNameSer1 = iVPNParameters.GetVPNNifDNS1();

    addr.iNameSer2 = iVPNParameters.GetVPNNifDNS2();

    LOG(TName name;

    name.AppendFormat(_L("[0x%08x]"), this);

    TBuf<39> addrBuf;

    iVPNParameters.GetVPNNifAddress().OutputWithScope(addrBuf);

    Log::Printf(_L("%s Vpn interface address = %s\n"),name.PtrZ(), addrBuf.PtrZ()));

    LOG(iVPNParameters.GetVPNNifDNS1().OutputWithScope(addrBuf);

    Log::Printf(_L("%s Vpn DNS1 = %s\n"),name.PtrZ(), addrBuf.PtrZ()));

    LOG(iVPNParameters.GetVPNNifDNS2().OutputWithScope(addrBuf);

    Log::Printf(_L("%s Vpn DNS2 = %s\n"),name.PtrZ(), addrBuf.PtrZ()));

    // Send VPN interface address to the tunnelnif

    iNotify->Notification((TAgentToNifEventType)EAgentToNifEventTypeSetAddress, (void*)(&addr));

    // Inform the Nifman

    iNotify->AgentProgress(EVPNConnAgtConnected, KErrNone);

    iNotify->ConnectComplete(aError); 

    iConnected = ETrue;

    // initialize real if observer

    iObserveRealIapConnDes().iRealIapConnInfo.iIapId = iVPNParameters.GetRealIapId();

    iObserveRealIapConnDes().iRealIapConnInfo.iNetId = iVPNParameters.GetRealNetworkId();

    iObserveRealIapConnDes().iVpnIapId = iVPNParameters.GetVPNIapId();

    ListenRealIAP();

    ListenAddressChange();

    iState = EListeningEvents;

    LOG_1("[0x%08x] VPN CONNECTION READY!\n", this);

    }

/****************************************************************************/

/* DisconnectionComplete()                                                  */

/****************************************************************************/

void CVPNConnAgt::DisconnectionComplete()

    {

    if ( iDisconnecting )

        {

        LOG(TName name;

        name.AppendFormat(_L("[0x%08x]"), this);

        Log::Printf(_L("%s Already disconnecting, return\n"),name.PtrZ()));

        return;

        }

    else

        iDisconnecting = ETrue;

    iNotify->AgentProgress(EVPNConnAgtDisconnecting, KErrNone);

    if ( iConnected && (iState == EListeningEvents || iState == EStartingRealIf) )

        {

        // Start the deactivate/unload of the VPN policies.

        CancelListeners();

        if ( iState == EStartingRealIf )

            iDisconnectType = (TDeactivateType)SILENT_DISCONNECT_MODE;

        iCloseVpnConnDes().iId = iEventMediator.NewEventSpecId();

        iCloseVpnConnDes().iIkePolicyHandle = iVPNParameters.GetIkePolicyHandle();

        iCloseVpnConnDes().iIpsecPolicyHandle = iVPNParameters.GetIpsecPolicyHandle();

        iCloseVpnConnDes().iDeactivateType = iDisconnectType;

        iCloseVpnConnDes().iVpnIapId = iVPNParameters.GetVPNIapId();

        iCloseVpnConnDes().iRealIapId = iVPNParameters.GetRealIapId();

        iEventMediator.ListenToEvent(ECloseVpnConnEvent, iCloseVpnConnDes, *this);

        iState = EClosingConnection;

        LOG(TName name;

        name.AppendFormat(_L("[0x%08x]"), this);

        Log::Printf(_L("%s Disconnecting type is %d\n"),name.PtrZ(), (TInt)iDisconnectType));

        return;

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdFfImsDeregistrationInVpn ) )

        {

        // SIP is re-registered when a VPN session ends.

        // Note: return value ignored. Nothing to do here for error cases.

        iSipObserver->RequestRegister();

        }

    iNotify->AgentProgress(EVPNConnAgtDisconnected, KErrNone);

    iNotify->DisconnectComplete();

    iDisconnecting = EFalse;

    }

/****************************************************************************/

/* EventOccured()                                                           */

/****************************************************************************/

void CVPNConnAgt::EventOccured(TInt aStatus, TEventType aType, TDesC8* aData)

    {

    LOG(TName name;

    name.AppendFormat(_L("[0x%08x]"), this);

    Log::Printf(_L("%s Event occured with status %d\n"),name.PtrZ(), aStatus));

    if ( aStatus == KErrServerTerminated )

        {                

        iNotify->Notification(EAgentToNifEventTypeDisableConnection, NULL);

        iConnected = EFalse; // Disable listening of ECloseVpnConnEvent event 

        return;

        }

    if ( aStatus != KErrNone || !aData )

        {

        if ( !iConnected )

            ConnectionComplete(aStatus);

        else

            DisconnectionComplete();

        return;

        }

    TGetProtocolVersionEventData* protocolVersion=NULL;

    TStartVpnConnEventData* connection = NULL;

    TCloseVpnConnEventData* closeData = NULL;

    switch (aType)

        {

        case EGetProtocolVersionEvent:

            protocolVersion = (TGetProtocolVersionEventData*)(aData->Ptr());

            if ( protocolVersion->iTaskStatus )

                {

                TProtocolVersion pv(EVersionIp);

                iVPNParameters.SetProtocolVersion(pv);

                }

            else          

                iVPNParameters.SetProtocolVersion(protocolVersion->iProtocolVersion);