/*

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

*

*/

#include <random.h>

#include "ikev2pluginsession.h"

#include "ikev2plugin.h"

#include "ikev2Negotiation.h"

#include "ikepolparser.h"

#include "ikedebug.h"

#include "ikev2SA.h"

#include "ikev2SAdata.h"

#include "ikedatainterface.h"

#include "ipsecsadata.h"

#include "ikev2pfkey.h"

#include "ipsecsalist.h"

#include "ipsecpolicyutil.h"

#include "ikev2messagesendqueue.h"

CIkev2PluginSession* CIkev2PluginSession::NewL( TUint32 aVpnIapId,

                                                TUint32 aVpnNetId,

                                                TUint32 aVpnInterfaceIndex,

                                                MIkeDataInterface& aDataInterface,

                                                CIkev2PlugIn& aPlugin, 

                                                CPFKeySocketIf& aPfKeySocketIf,

                                                CIpsecPolicyUtil& aIpsecPolicyUtil,

                                                MKmdEventLoggerIf& aEventLogger,

                                                MIkeDebug& aDebug )

    {

    CIkev2PluginSession* self = new (ELeave) CIkev2PluginSession( aVpnIapId, aVpnNetId, 

                                                                  aVpnInterfaceIndex, aDataInterface,

                                                                  aPlugin, aPfKeySocketIf, aIpsecPolicyUtil,

                                                                  aEventLogger, aDebug );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CIkev2PluginSession::CIkev2PluginSession( TUint32 aVpnIapId,

                                          TUint32 aVpnNetId,

                                          TUint32 aVpnInterfaceIndex,

                                          MIkeDataInterface& aDataInterface,

                                          CIkev2PlugIn& aPlugin,

                                          CPFKeySocketIf& aPfKeySocketIf,

                                          CIpsecPolicyUtil& aIpsecPolicyUtil,

                                          MKmdEventLoggerIf& aEventLogger,

                                          MIkeDebug& aDebug )

: iVpnIapId(aVpnIapId), iVpnNetId(aVpnNetId),  iDataInterface(aDataInterface), iPlugin(aPlugin), 

  iPfKeySocketIf(aPfKeySocketIf), iIpsecPolicyUtil(aIpsecPolicyUtil), iEventLogger(aEventLogger), 

  iDebug(aDebug), iVpnInterfaceIndex(aVpnInterfaceIndex) 

    {

    }

void CIkev2PluginSession::ConstructL()

    {

    TPtr8 ptr((TUint8*)&iSAIdSeed, sizeof(iSAIdSeed));

    ptr.SetLength(sizeof(iSAIdSeed));

    TRandom::RandomL(ptr);  

    iSAIdSeed &= 0x7fffffff;  // Reset the most significant bit

    DEBUG_LOG1(_L("CIkev2Plugin::ConstructL, SAId seed: %d"), iSAIdSeed );

    }

CIkev2PluginSession::~CIkev2PluginSession()

    {

    //Makes sure that all the negotiations and

    //Sa data structures are deleted:

    while ( iFirstNegotiation )

        {

        CIkev2Negotiation* negotiation = iFirstNegotiation;

        iFirstNegotiation = iFirstNegotiation->iNext;

        delete negotiation;

        }

    while(iFirstIkev2SA)

        {

        CIkev2SA* ikeV2Sa = iFirstIkev2SA;

        iFirstIkev2SA = ikeV2Sa->iNext;

        delete ikeV2Sa;

        }        

    delete iMessageSendQue;

    delete iReceiver;    

    delete iIkeData; 

    delete iDeactivationTimer;    

    iPlugin.PluginSessionDeleted(this);

    }

void CIkev2PluginSession::NegotiateWithHost( const CIkeData& aIkeData,

                                             TVPNAddress& aInternalAddress,

                                             TRequestStatus& aStatus )

    {

    __ASSERT_DEBUG(iClientStatusNegotiate == NULL,

                   User::Invariant());

    iClientStatusNegotiate = &aStatus;

    *iClientStatusNegotiate = KRequestPending;

    iInternalAddress = &aInternalAddress;

    TRAPD(err, DoNegotiateWithHostL(aIkeData));

    if (err != KErrNone)

        {

        DoCompleteNegotiateWithHost(err);

        }    

    }

void CIkev2PluginSession::DoNegotiateWithHostL( const CIkeData& aIkeData )

    {

    iIkeData = CIkeData::NewL(&aIkeData);

    iReceiver = CIkev2Receiver::NewL( iDataInterface,

                                      *this );   

    iMessageSendQue = CIkev2MessageSendQueue::NewL(iDataInterface, 

                                                   iIkeData->iAddr, 

                                                   iIkeData->iDscp,

                                                   iIkeData->iNatKeepAlive,

                                                   iDebug);    

    TInetAddr physicalAddr;

    iDataInterface.GetLocalAddress(physicalAddr);

    TInetAddr sgwAddr(iIkeData->iAddr);       

    // Negotiation ownership is transferred to the plugin

    // before leave can occur.

    iSAIdSeed++;

    if (aIkeData.iUseInternalAddr)

        {

        CIkev2Negotiation* Negotiation = CIkev2Negotiation::NewL(*this, iPfKeySocketIf, iEventLogger,

                                                                 *iMessageSendQue, iDebug, iIkeData, 

                                                                 iVpnIapId, iSAIdSeed,

                                                                 physicalAddr, sgwAddr);

        Negotiation->StartIkeSANegotiationL();

        }

    else

        {

        //If internall addressing is not in use, we do not do anything else

        //in this phase. The actual IKE negotiation is trickered by an Acquire

        //PFKEY message from the IPsec, when there is actual data between the SGW and

        //the phone.

        DoCompleteNegotiateWithHost( KErrNone);

        }

    }

void CIkev2PluginSession::CancelNegotiateWithHost()

    {

    if (iClientStatusNegotiate != NULL)

        {

        //If the Negotiate with host is cancelled we pretty much do a silent close

        //for the connection

        while ( iFirstNegotiation )

            {

            CIkev2Negotiation* negotiation = iFirstNegotiation;

            iFirstNegotiation = iFirstNegotiation->iNext;

            delete negotiation;

            }

        while(iFirstIkev2SA)

            {

            CIkev2SA* ikeV2Sa = iFirstIkev2SA;

            iFirstIkev2SA = ikeV2Sa->iNext;

            delete ikeV2Sa;

            }

        DoCompleteNegotiateWithHost(KErrCancel);

        }            

    }

void CIkev2PluginSession::DeleteSession( const TBool aSilentClose,

                                         TRequestStatus& aStatus )

    {

    DEBUG_LOG1(_L("Deactivating IKE SA:s for vpn iap %d"), iVpnIapId);

    __ASSERT_DEBUG(iClientStatusDelete == NULL, User::Invariant());

    iClientStatusDelete = &aStatus;

    *iClientStatusDelete = KRequestPending;

    TInt err = KErrNone;

    TBool doSilentClose = aSilentClose;

    //Deletes all ongoing ike negotiations    

    while ( iFirstNegotiation )

        {

        CIkev2Negotiation* negotiation = iFirstNegotiation;

        iFirstNegotiation = iFirstNegotiation->iNext;

        delete negotiation;

        }

    TBool deactivating = EFalse;

    while(iFirstIkev2SA)

        {

        CIkev2SA* ikeV2Sa = iFirstIkev2SA;

        iFirstIkev2SA = ikeV2Sa->iNext;

        if (!doSilentClose)

            {

            TRAP(err, DoDeleteIkeSAExhangeL(ikeV2Sa->iIkeV2SaData));

            if (err == KErrNone)

                {

                deactivating = ETrue;

                }

            else

                {

                //If we can't start the IKE SA delete exhange, 

                //we do following expection handling:

                //1. Possible already active delete exhanges can continue as they were.

                //2. The IKE SA, which delete exchange failured, is deleted silently.

                //3. The rest of the IKE SAs are deleted silently.

                //4. The caller is notified with the error returned by the failed delete 

                //   exchange attempt, if no delete exhanges are in progress.

                //5. If there is ongoing delete exhange(s), the caller is notified with the

                //   status of last delete exhange, which completes.

                DEBUG_LOG1(_L("CIkev2PluginSession::DeleteSession: Can't start IKE SA delete exhange (%d)"), 

                           err );

                doSilentClose = ETrue;

                }

            }

        delete ikeV2Sa;

        }

    if (deactivating)

        {

        TRAP( err, iDeactivationTimer = CIkev2DeactivationTimer::NewL(*this) );

        }

    if (deactivating &&

        err == KErrNone)

        {

        iDeactivationTimer->IssueRequest();

        }

    else

        {

        delete iIkeData;

        iIkeData = NULL;

        DoCompleteDeleteSession(err);        

        }    

    }

void CIkev2PluginSession::DoDeleteIkeSAExhangeL(TIkev2SAData& aIkev2SAdata)

    {

    DEBUG_LOG1(_L("Deleting IKE SA SAID =  %d"), aIkev2SAdata.SaId());

    }

void CIkev2PluginSession::CancelDeleteSession()

    {

    if (iClientStatusDelete != NULL)

        {

        //If the delete sessionis cancelled we pretty much do a silent close

        //for the connection

        iMessageSendQue->CancelAll();

        iReceiver->Cancel();    

        delete iDeactivationTimer;

        iDeactivationTimer = NULL;

        while ( iFirstNegotiation )

            {

            CIkev2Negotiation* negotiation = iFirstNegotiation;

            iFirstNegotiation = iFirstNegotiation->iNext;

            delete negotiation;

            }

        while(iFirstIkev2SA)

            {

            CIkev2SA* ikeV2Sa = iFirstIkev2SA;

            iFirstIkev2SA = ikeV2Sa->iNext;

            delete ikeV2Sa;

            }

        DoCompleteDeleteSession(KErrCancel);

        }            

    }

void CIkev2PluginSession::NotifyError( TRequestStatus& aStatus )

    {

    aStatus = KRequestPending;

    iClientStatusNotifyError = &aStatus;

    }

void CIkev2PluginSession::CancelNotifyError()

    {    

    if (iClientStatusNotifyError != NULL)

        {

        DoCompleteNotifyError(KErrCancel);

        }

    }

void CIkev2PluginSession::NotifyInternalAddressChanged( TVPNAddress& aInternalAddress,

                                                        TRequestStatus& aStatus )

    {

    __ASSERT_DEBUG(iClientStatusInternalAddressChange == NULL,

                    User::Invariant());    

    __ASSERT_DEBUG(iChangedInternalAddress == NULL,

                    User::Invariant());    

    iClientStatusInternalAddressChange = &aStatus;

    *iClientStatusInternalAddressChange = KRequestPending;

    iChangedInternalAddress = &aInternalAddress;

    }

void CIkev2PluginSession::CancelNotifyInternalAddressChanged()

    {

    if (iClientStatusInternalAddressChange != NULL)

        {

        __ASSERT_DEBUG(iChangedInternalAddress != NULL, User::Invariant());

        iChangedInternalAddress = NULL;

        User::RequestComplete(iClientStatusInternalAddressChange, KErrCancel);

        }

    }

void CIkev2PluginSession::LinkNegotiation(CIkev2Negotiation* aNegotiation)

{  

    ASSERT(aNegotiation); 

    aNegotiation->iNext = iFirstNegotiation;  

    iFirstNegotiation = aNegotiation; 

}

void CIkev2PluginSession::RemoveNegotiation(CIkev2Negotiation* aNegotiation)

    {

        CIkev2Negotiation* Prev = NULL;

        CIkev2Negotiation* Neg  = iFirstNegotiation;

        while ( Neg )

        {

            if ( Neg == aNegotiation )

            {

               if ( Prev )

                    Prev->iNext = Neg->iNext;

               else iFirstNegotiation = Neg->iNext;

               break;  

            }

            Prev = Neg;

            Neg  = Neg->iNext;

        }   

    }

//

// Find an IKEv2 SA using SA Id as search argument

//

CIkev2SA* CIkev2PluginSession::FindIkev2SA(TUint32 aSAId, TInt aRequiredState, TInt aNewState)

{

    CIkev2SA* Sa = iFirstIkev2SA;

    while ( Sa )

    {

        if ( ( Sa->iIkeV2SaData.SaId() == aSAId )

              &&

           ( ( aRequiredState == KSaStateNotDefined) ||

             ( aRequiredState == Sa->iIkeV2SaData.iSAState ) ) )

        {

           if ( aNewState != KSaStateNotDefined )

               Sa->iIkeV2SaData.iSAState = aNewState;  

           break;

        }   

        Sa = Sa->iNext;

    }   

    return Sa;

}

TBool CIkev2PluginSession::UpdateIkev2SAL(TIkev2SAData* aIkev2SAData, TIkeV2IpsecSAData* aIpsecSAData)

    {

    ASSERT(aIkev2SAData);

    CIkev2SA* Ikev2SA = FindIkev2SA(aIkev2SAData->SaId(), KSaStateNotDefined, KSaStateNotDefined);

    if ( Ikev2SA )

        {

        Ikev2SA->UpdateL(aIkev2SAData, aIpsecSAData);

        return ETrue;

        }

    else 

        {

        return EFalse;

        }

    }

TIkeV2IpsecSAData* CIkev2PluginSession::FindIpsecSAData(TUint32 aSAId, const TDesC8& aSpi, TBool aInbound)

    {

    __ASSERT_ALWAYS(aSpi.Length() == 4, User::Invariant());

    _LIT8(KZeroSpi, "");

    TIkeV2IpsecSAData* SaData = NULL;        

    CIkev2SA* Ikev2SA = FindIkev2SA(aSAId, KSaStateNotDefined, KSaStateNotDefined);

    if ( Ikev2SA )

        {

        if ( aInbound ) 

            SaData = Ikev2SA->FindIpsecSaData(aSpi, KZeroSpi, EFalse); 

        else SaData = Ikev2SA->FindIpsecSaData(KZeroSpi, aSpi, EFalse);    

        }   

    return SaData;

    }

//

// Delete an IKEv2 SA using SA Id as search argument

//

void CIkev2PluginSession::DeleteIkev2SA(TUint32 aSAId)

{

    CIkev2SA* Sa     = iFirstIkev2SA;

    CIkev2SA* PrevSa = NULL;

    while ( Sa )

    {

        if ( Sa->iIkeV2SaData.SaId() == aSAId )

        {

            if ( PrevSa )

                {

                PrevSa->iNext = Sa->iNext;

                }

            else

                {

                iFirstIkev2SA = Sa->iNext;

                }

            if (Sa->iIkeV2SaData.iFloatedPort)

                {

                iMessageSendQue->SaBehindNatDeleted(Sa->iIkeV2SaData.SaId());

                }

            delete Sa;

            break;

        }

        PrevSa = Sa;

        Sa     = Sa->iNext;

    }   

}

TUint32 CIkev2PluginSession::GetSAId()    

    { 

    iSAIdSeed++; 

    return iSAIdSeed; 

    }

TBool CIkev2PluginSession::CreateIkev2SAL(TIkev2SAData& aIkev2SAData)

    {

    CIkev2SA* Ikev2SA = CIkev2SA::NewL(*this, aIkev2SAData, iDebug);

    if (aIkev2SAData.iFloatedPort)

        {

        CleanupStack::PushL(Ikev2SA);

        iMessageSendQue->NewSaBehindNatL(aIkev2SAData.SaId());

        CleanupStack::Pop(Ikev2SA);

        }

    Ikev2SA->iNext = iFirstIkev2SA; 

    iFirstIkev2SA = Ikev2SA; 

    return ETrue;

    }

void CIkev2PluginSession::IkeSaCompleted(TInt aStatus, TVPNAddress& aInternalAddress)

{       

   if (iClientStatusNegotiate != NULL)

       {

       //This is the first IKE sa of this session

       if (!aInternalAddress.iVPNIfAddr.IsUnspecified())

           {

           *iInternalAddress = aInternalAddress;

           }

       // Completion is postponed, if IPsec SAs have not yet been updated.

       if (iActivated ||

           aStatus != KErrNone)

           {           

           DoCompleteNegotiateWithHost(aStatus);

           }

       }

   else if (aStatus == KErrNone)

       {

       //This is not the first IKE SA in this session.

       //If IA has changed we notify the possible address change

       if(!aInternalAddress.iVPNIfAddr.IsUnspecified())

           {

           VirtualIpChanged(aInternalAddress);

           }

       }

   else if(iClientStatusNotifyError != NULL)

       {

       //Ike sa establishmet has failed.

       DoCompleteNotifyError(aStatus);

       }

}