/*

* Copyright (c) 2008-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:  IKEv1 plugin session

*

*/

#include <random.h>

#include <vpnlogmessages.rsg>

#include "ikev1plugin.h"

#include "ikedebug.h"

#include "ikev1negotiation.h"

#include "ikev1isakmpstream.h"

#include "pfkeymsg.h"

#include "ikepolparser.h"

#include "kmdapi.h"

#include "ikev1crack.h"

#include "ikev1infonegotiation.h"

#include "ikev1SA.h"

#include "ikev1sender.h"

#include "ikesocketdefs.h"

#include "ikedatainterface.h"

#include "vpnaddrinfo.h"

#include "ipsecsaspiretriever.h"

// CLASS HEADER

#include "ikev1pluginsession.h"

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

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

// Two-phased constructor.

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

//

CIkev1PluginSession* CIkev1PluginSession::NewL( TUint32 aVpnIapId,

                                                TUint32 aVpnNetId,

                                                TUint32 aVpnInterfaceIndex,

                                                MIkeDataInterface& aDataInterface,

                                                CIkev1Plugin& aPlugin,

                                                CPFKeySocketIf& aPFKeySocketIf,

                                                MIkeDebug& aDebug )

    {

    CIkev1PluginSession* self = new ( ELeave ) CIkev1PluginSession( aVpnIapId,

                                                                    aVpnNetId,

                                                                    aVpnInterfaceIndex,

                                                                    aDataInterface,

                                                                    aPlugin,

                                                                    aPFKeySocketIf,

                                                                    aDebug );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CIkev1PluginSession::~CIkev1PluginSession()

    {

    // Cancel client's requests.

    DoCompleteNegotiateWithHost( KErrCancel );

    DoCompleteDeleteSession( KErrCancel );

    DoCompleteNotifyError( KErrCancel );

    DoCompleteInternalAddressChanged( KErrCancel );    

    if ( iDialogWaitQueue )

        {

        CIkev1Dialog::PurgeDialogQueue( iDialogWaitQueue );

        }   

    CIkev1Negotiation* negotiation;    

    while ( iFirstNegotiation )

        {

        negotiation = iFirstNegotiation;

        delete negotiation; // destructor removes object from queue, too

        }

    DoEmptySendQueue();

    iSendQueue.Close();

    while ( iIkev1SAs.Count() )

        {

        CIkev1SA* ikev1SA = iIkev1SAs[0];

        iIkev1SAs.Remove(0);

        delete ikev1SA;

        }

    iIkev1SAs.Close();

    delete iReceiver;

    delete iSender;

    delete iIkeData;

    delete iInternalAddress;

    iPlugin.IkePluginSessionDeleted( this );

    }

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

// Constructor.

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

//

CIkev1PluginSession::CIkev1PluginSession( TUint32 aVpnIapId,

                                          TUint32 aVpnNetId,

                                          TUint32 aVpnInterfaceIndex,

                                          MIkeDataInterface& aDataInterface,

                                          CIkev1Plugin& aPlugin,

                                          CPFKeySocketIf& aPFKeySocketIf,

                                          MIkeDebug& aDebug )

: iVpnIapId( aVpnIapId ),

  iVpnNetId( aVpnNetId ),

  iVpnInterfaceIndex( aVpnInterfaceIndex ),

  iDataInterface( aDataInterface ),

  iPlugin( aPlugin ),

  iPFKeySocketIf( aPFKeySocketIf ),

  iDebug( aDebug )

    {

    }

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

// Second phase construction.

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

//

void CIkev1PluginSession::ConstructL()

    {

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

    ptr.SetLength( sizeof(iSAIdSeed) );

    TRandom::RandomL( ptr );  

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

    iReceiver = CIkev1Receiver::NewL( iDataInterface,

                                      *this );   

    iSender = CIkev1Sender::NewL( iDataInterface,

                                  *this,

                                  iDebug );    

    DEBUG_LOG1( _L("CIkev1PluginSession::ConstructL, SAId seed: %d"),

            iSAIdSeed );

    }    

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

// Handles IKE SA deletion request.

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

//

TBool CIkev1PluginSession::DeleteIkeSA( TIkev1SAData* aIkev1SaData,

                                        TBool aSilentClose )

    {

    //

    // An IKE SA delete request received

    // Check first does there exists an ongoing negotiation on this IKE

    // SA deleted and delete this block. 

    // Allocate a new negotiation with TIkev1SAData and initiate IKE SA

    // deletion request

    //

    DEBUG_LOG1( _L("Deleting IKEv1 SA SAID =  %d"),

            aIkev1SaData->iSAId );

    CIkev1Negotiation* negotiation = FindNegotiation( aIkev1SaData->iSAId );

    while ( negotiation )

        {

        delete negotiation; // destructor removes object from queue, too

        negotiation = FindNegotiation( aIkev1SaData->iSAId );         

        }

    TBool started( EFalse );

    if ( !aSilentClose )

        {

        DeleteIpsecSAs( aIkev1SaData->iSAId );

        TRAPD( err, 

                {

                // Trap the SendDeleteL -- it can fail, but the failure won't be fatal 

                // (delete payload just won't be sent)

                negotiation = CIkev1Negotiation::NewL( this,

                                                       iPFKeySocketIf,

                                                       iDebug,

                                                       aIkev1SaData,

                                                       RESPONDER ); // Nevermind INITIATOR or RESPONDER

                negotiation->SendDeleteL( PROTO_ISAKMP );

                } );

        delete negotiation;

        negotiation = NULL;

        if ( err == KErrNone ) 

            {

            // DELETE payload sent succesfully.

            DEBUG_LOG( _L("CIkev1PluginSession::DeleteIkeSAL() IKEv1 delete send OK") );            

            started = ETrue;

            }

        else 

            {

            DEBUG_LOG1( _L("CIkev1PluginSession::DeleteIkeSAL() IKEv1 delete send failed, err=%d"), err );

            }

        }

#ifdef _DEBUG

    else

        {

        DEBUG_LOG( _L("Forced close, no delete payload(s) sent"));

        }

#endif    

    ExpireIkev1SA( aIkev1SaData->iSAId );  // Set expired to delete IKE SA

    if ( FindIkev1SA() == NULL &&

         FirstNegotiation() == NULL )

        {

        // Set error status, when expired IKE SA was the only IKE SA and there

        // is no ongoing negotiation.        

        iErrorStatus = KKmdIkeNegotFailed;

        }

    return started;

    }

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

// Handles IKE SA rekeying request.

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

//

void CIkev1PluginSession::RekeyIkeSAL( TIkev1SAData* aIkev1SaData,

                                       CSARekeyInfo* aSaRekeyInfo )

    {

    CIkev1Negotiation* negotiation = CIkev1Negotiation::NewL( this,

                                                              iPFKeySocketIf,

                                                              iDebug,

                                                              aIkev1SaData->iRemoteAddr,

                                                              EFalse );

    CleanupStack::PushL( negotiation );

    negotiation->SetRekeyInfo( aSaRekeyInfo );                

    negotiation->InitNegotiationL();

    if ( negotiation->Finished() )

        {

        CleanupStack::PopAndDestroy( negotiation );

        }

    else 

        {

        CleanupStack::Pop( negotiation );  

        }

    }

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

// Handles IKE SA keepalive request.

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

//

void CIkev1PluginSession::KeepAliveIkeSAL( TIkev1SAData* aIkev1SaData )

    {

    CIkev1Negotiation* negotiation = CIkev1Negotiation::NewL( this,

                                                              iPFKeySocketIf,

                                                              iDebug,

                                                              aIkev1SaData,

                                                              RESPONDER );

    CleanupStack::PushL( negotiation );

    negotiation->SendKeepAliveMsgL( aIkev1SaData );

    if ( negotiation->Finished() )

        {

        CleanupStack::PopAndDestroy( negotiation );

        }

    else

        {

        CleanupStack::Pop( negotiation );  

        }

    }

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

// Creates IKE SA.

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

//

void CIkev1PluginSession::CreateIkev1SAL( TIkev1SAData& aIkev1SaData,

                                          CSARekeyInfo* aSaRekey )

    {

    CIkev1SA* ikev1SA = CIkev1SA::NewL( *this,

                                        aIkev1SaData,

                                        aSaRekey,

                                        iDebug );

    if ( !aIkev1SaData.iInitiator )

        {

        // Move SPI list from previous IKE SA to new IKE SA

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

            {

            CIkev1SA* previousSA = iIkev1SAs[i];

            if ( previousSA->iSPIList != NULL )

                {

                DEBUG_LOG(_L("Move SPI list to new IKE SA"));

                delete ikev1SA->iSPIList;

                ikev1SA->iSPIList = previousSA->iSPIList;

                previousSA->iSPIList = new (ELeave) CIpsecSPIList(1);  // Dummy;

                break;

                }

            }        

        }        

    // Cancel IKE SA rekeying from other IKE SAs.

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

        {

        CIkev1SA* cancelSA = iIkev1SAs[i];

        cancelSA->CancelRekey();

        }

    CleanupStack::PushL( ikev1SA );

    iIkev1SAs.AppendL( ikev1SA );

    CleanupStack::Pop( ikev1SA );    

    }

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

// Updates IKE SA.

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

//

void CIkev1PluginSession::UpdateIkev1SAL( TUint32 aSaId,

                                          TBool aExpired,

                                          TIkev1SAData* aIkev1SaData )

    {

    if ( !aExpired )

        {

        CIkev1SA* Ikev1SA = FindIkev1SAWithId( aSaId );

        if ( Ikev1SA )

            {

            Ikev1SA->UpdateSAL( aExpired, aIkev1SaData );

            }

        }

    else

        {

        ExpireIkev1SA( aSaId );

        }

    }

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

// Expires IKE SA.

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

//

void CIkev1PluginSession::ExpireIkev1SA( TUint32 aSaId )

    {

    CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

    if ( ikev1SA )

        {

        ikev1SA->ExpireSA();

        }

    }

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

// Removes IKE SA.

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

//

void CIkev1PluginSession::RemoveIkeSA( CIkev1SA* aIkev1Sa,

                                       TInt aStatus )

    {        

    TInt dpdRetryCount( 0 );

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

        {

        CIkev1SA* sa = iIkev1SAs[i]; 

        if ( aIkev1Sa == sa )

            {

            // Remove IKE SA from array.

            dpdRetryCount = sa->iHdr.iDPDRetry;

            iIkev1SAs.Remove(i);

            delete sa;

            break;

            }   

        }

    if ( (iErrorStatus == KErrNone) &&

         (dpdRetryCount > KMaxDpdRetryCount) &&

         (FindIkev1SA() == NULL) )

        {

        // If DPD retry count was reached for only IKE SA, set error status.

        iErrorStatus = KKmdIkeNoResponseErr;        

        }

    // If session deletion has been requested, complete session deletion

    // request.        

    DoCompleteDeleteSession( aStatus );

    // If fatal error has occured, complete error notification.    

    if ( iErrorStatus != KErrNone )

        {

        DoHandleError( iErrorStatus );

        }

    }

// IKE SA find methods.

CIkev1SA* CIkev1PluginSession::FindIkev1SA()

    {

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

        {

        CIkev1SA* sa = iIkev1SAs[i]; 

        if ( (!sa->IsExpired()) )

            {

            return sa;

            }   

        }

    return NULL;

    }

CIkev1SA* CIkev1PluginSession::FindIkev1SA( const TCookie& aCookie_I,

                                            const TCookie& aCookie_R )

    {

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

        {

        CIkev1SA* sa = iIkev1SAs[i]; 

        if ( (sa->iHdr.iCookie_I ==  aCookie_I) &&

             (sa->iHdr.iCookie_R ==  aCookie_R) &&

             (!sa->IsExpired()) )

            {

            return sa;

            }   

        }

    return NULL;

    }

CIkev1SA* CIkev1PluginSession::FindIkev1SAWithId( TUint32 aSaId )

    {

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

        {

        CIkev1SA* sa = iIkev1SAs[i]; 

        if ( (sa->iHdr.iSAId == aSaId) &&

             (!sa->IsExpired()) )

            {

            return sa;

            }   

        }

    return NULL;

    }

CIkev1SA* CIkev1PluginSession::FindIkev1SA( const TInetAddr& aAddr )

    {

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

        {

        CIkev1SA* sa = iIkev1SAs[i]; 

        if (  sa->iHdr.iRemoteAddr.Match(aAddr) &&

              (!sa->IsExpired()) ) 

            {

            return sa;

            }   

        }

    return NULL;

    }

CIkev1SA* CIkev1PluginSession::FindIkev1SA( const TInetAddr& aAddr,

                                            TUint32 aInboundSpi )

    {

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

        {

        CIkev1SA* sa = iIkev1SAs[i]; 

        if (  sa->iHdr.iRemoteAddr.Match(aAddr) &&

              (!sa->IsExpired()) ) 

            {

            if ( sa->FindIpsecSPI(aInboundSpi, ETrue) )

                {

                return sa;

                }

            }   

        }

    return NULL;

    }

TIkev1SAData* CIkev1PluginSession::FindIkev1SAData()

    {

    TIkev1SAData* saData = NULL;        

    CIkev1SA* ikev1SA = FindIkev1SA();

    if ( ikev1SA )

        {

        saData = (TIkev1SAData*)&ikev1SA->iHdr;

        }

    return saData;

    }

TIkev1SAData* CIkev1PluginSession::FindIkev1SAData( const TCookie& aCookie_I,

                                                    const TCookie& aCookie_R )

    {

    TIkev1SAData* saData = NULL;        

    CIkev1SA* ikev1SA = FindIkev1SA( aCookie_I, aCookie_R );

    if ( ikev1SA )

        {

        saData = (TIkev1SAData*)&ikev1SA->iHdr;

        }

    return saData;

    }

TIkev1SAData* CIkev1PluginSession::FindIkev1SAData( TUint32 aSaId )

    {

    TIkev1SAData* saData = NULL;        

    CIkev1SA* ikev1SA = FindIkev1SAWithId( aSaId );

    if ( ikev1SA )

        {

        saData = (TIkev1SAData*)&ikev1SA->iHdr;

        }

    return saData;

    }

TIkev1SAData* CIkev1PluginSession::FindIkev1SAData( const TInetAddr& aAddr,

                                                    TUint32 aInboundSpi )

    {

    TIkev1SAData* saData = NULL;        

    CIkev1SA* ikev1SA = FindIkev1SA( aAddr, aInboundSpi );

    if ( ikev1SA )

        {

        saData = (TIkev1SAData*)&ikev1SA->iHdr;

        }

    return saData;

    }    

TIkev1SAData* CIkev1PluginSession::FindIkev1SADataWithAddr( const TInetAddr& aAddr )

    {

    TIkev1SAData* saData = NULL;        

    CIkev1SA* ikev1SA = FindIkev1SA( aAddr );

    if ( ikev1SA )

        {

        saData = (TIkev1SAData*)&ikev1SA->iHdr;

        }

    return saData;

    }    

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

// Handles IPsec SA deletion request.

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