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

// Name          : CIpSecSadbHandler.cpp

// Part of       : SIPSec

// Version       : SIP/4.0 

//

#include <pfkey_send.h>

#include <lib_pfkey.h>

#include "siprequest.h"

#include "sipresponse.h"

#include "sipsecurityclientheader.h"

#include "sipsecurityserverheader.h"

#include "sipsecurityverifyheader.h"

#include "CIpSecSadbHandler.h"

#include "MSipSecSaDbSendReceiveObserver.h"

#include "SipSecIpsecParams.h"

#include "SipSecUtils.h"

#include "CSipSecSaDbMsgSender.h"

#include "CSipSecSaDbMsgReceiver.h"

#include "MIpSecMechanismParams.h"

#include "MSipSecSadbObserver.h"

const TInt KOngoingAddsGranularity = 4;

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

// CIpSecSadbHandler::NewL

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

//

CIpSecSadbHandler* CIpSecSadbHandler::NewL( 

    MSipSecSadbObserver& aObserver, 

    RSADB& aSADB )

	{

   	CIpSecSadbHandler* self = new ( ELeave ) CIpSecSadbHandler( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL( aSADB );

	CleanupStack::Pop( self );

	return self;

	}

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

// CIpSecSadbHandler::ConstructL

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

//	

void CIpSecSadbHandler::ConstructL( RSADB& aSADB )

    {

   	iSaDbMsgSender = CSipSecSaDbMsgSender::NewL( *this, aSADB );

    }

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

// CIpSecSadbHandler::CIpSecSadbHandler

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

//	

CIpSecSadbHandler::CIpSecSadbHandler( MSipSecSadbObserver& aObserver ) : 

    iObserver( aObserver ),

    iState( EAvailable ),

    iOngoingAdds( KOngoingAddsGranularity )

	{

	}

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

// CIpSecSadbHandler::~CIpSecSadbHandler

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

//	

CIpSecSadbHandler::~CIpSecSadbHandler()

	{

	delete iSaDbMsgSender;

	iOngoingAdds.Reset();

	iOngoingAdds.Close();

	}

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

// CIpSecSadbHandler::AddSasL

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

//	

void CIpSecSadbHandler::AddSasL(

	MIpSecMechanismParams& aParams,

	TInetAddr aLocalAddress,

	TInetAddr aRemoteAddress,

	TSipSecSaParams& aSaParams )

	{

	IssueRequestL( aParams, 

	               aLocalAddress, 

	               aRemoteAddress, 

	               aSaParams );

    // Kick-start SA adding looping

    AddCompletedL( KErrNone );

	}

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

// CIpSecSadbHandler::DeleteSasL

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

//	

void CIpSecSadbHandler::DeleteSasL( 

	MIpSecMechanismParams& aParams,

	TInetAddr aLocalAddress,

	TInetAddr aRemoteAddress,

	TSipSecSaParams& aSaParams )

	{

	CancelAddSaOps();

	IssueRequestL( aParams, 

	               aLocalAddress, 

	               aRemoteAddress, 

	               aSaParams );

	// Kick-start SA deleting looping

    DeleteCompletedL();	

	}

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

// CIpSecSadbHandler::SetSaParamsL

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

//				

void CIpSecSadbHandler::SetSaParamsL( 

	TSipSecSaParams& aParams, 				     

	CSIPSecurityHeaderBase& aCliHeader, 

	CSIPSecurityHeaderBase& aSrvHeader,

	const TDesC8& aAuthKey )

	{

	TInt len = aAuthKey.Length();

	__ASSERT_ALWAYS( len == KAuthKeyFromSIMSize && len <= KAuthKeyMaxSize, 

	                 User::Leave( KErrArgument ) );

	aParams.iSpi_uc  = SipSecUtils::ValueL( aCliHeader, KSpic );

	aParams.iSpi_us  = SipSecUtils::ValueL( aCliHeader, KSpis );

	aParams.iPort_uc = SipSecUtils::ValueL( aCliHeader, KPortc );

	aParams.iPort_us = SipSecUtils::ValueL( aCliHeader, KPorts );

	aParams.iSpi_pc  = SipSecUtils::ValueL( aSrvHeader, KSpic );

	aParams.iSpi_ps  = SipSecUtils::ValueL( aSrvHeader, KSpis );

	aParams.iPort_pc = SipSecUtils::ValueL( aSrvHeader, KPortc );

	aParams.iPort_ps = SipSecUtils::ValueL( aSrvHeader, KPorts );

	RStringF v = SipSecUtils::ValueFL( aCliHeader, KAlgorithm );

	const TDesC8& alg = v.DesC();

	__ASSERT_ALWAYS( alg.Length(),User::Leave( KErrNotReady ) );	  

	if ( alg == KHmacMd596 )

	    {

	    aParams.iAuthAlg = SADB_AALG_MD5HMAC;

	    aParams.iAuthKey.Copy( aAuthKey );

	    }

	else

	    {

	    aParams.iAuthAlg = SADB_AALG_SHA1HMAC;

	    // In hmac-sha-1-96 160 bit key has to be used, aAuthKey retrieved

	    // from SIM should be only 128 bits, pad with zeros from right

        const TUint KPadLength = 4;

        __ASSERT_ALWAYS( KAuthKeyFromSIMSize + KPadLength <= KAuthKeyMaxSize,

                         User::Leave( KErrOverflow ) );

	    TBuf8<KAuthKeyMaxSize> authkey;

	    authkey.Append( aAuthKey );

	    const TUint KPosKeyEnd = authkey.Length();

	    authkey.SetMax();

	    LittleEndian::Put32( &authkey[ KPosKeyEnd ], 0 );

	    aParams.iAuthKey.Copy( authkey );

	    }

	}

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

// CIpSecSadbHandler::CancelAddSAOps

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

//	

void CIpSecSadbHandler::CancelAddSaOps()

    {

    if ( iSaDbMsgSender->Type() == SADB_ADD )

        {

        iSaDbMsgSender->Cancel();

        Reset();

        }

    }

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

// CIpSecSadbHandler::SADBAddMsgReceived

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

//       

void CIpSecSadbHandler::SADBAddMsgReceived( TUint aMsgSeq, TInt aError )

    {

    TInt index = iOngoingAdds.FindInOrder( aMsgSeq );

    if ( index != KErrNotFound )

        {

        iOngoingAdds.Remove( index );

        iOngoingAdds.Compress();

        TBool aSuccess( !aError );

        TRAP_IGNORE( SAsAddedL( aSuccess ) )

        }

    }

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

// CIpSecSadbHandler::MessageSentL

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

//

void CIpSecSadbHandler::MessageSentL( TInt aStatus, TInt aMsgType )

	{

	if ( aMsgType == SADB_ADD )

	    {

	    AddCompletedL( aStatus );

	    }

	else

	    {

	    // Error is ignored since anyway we should try to delete existing SAs

	    DeleteCompletedL();

	    }

	}

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

// CIpSecSadbHandler::MessageReceived

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

//

void CIpSecSadbHandler::MessageReceived( TInt /* aStatus */ )

	{

	// Not used in this context

	}

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

// CIpSecSadbHandler::IssueRequestL

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

//

void CIpSecSadbHandler::IssueRequestL(

    MIpSecMechanismParams& aParams,

	TInetAddr& aLocalAddress,

	TInetAddr& aRemoteAddress,

	TSipSecSaParams& aSaParams )

    {

   	if ( !IsAvailable() )

	    {

	    User::Leave( KErrInUse );

	    }

	// Remember parameters regarding current request

	iParams = &aParams;

	iSaParams = &aSaParams;

	iLocalAddress = aLocalAddress;

	iRemoteAddress = aRemoteAddress;

    }

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

// CIpSecSadbHandler::IsAvailable

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

//   

TBool CIpSecSadbHandler::IsAvailable()

    {

    return ( iState == EAvailable );

    }

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

// CIpSecSadbHandler::Reset

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

//    

void CIpSecSadbHandler::Reset()

    {

    iState = EAvailable;

    iOngoingAdds.Reset();

    iOngoingAdds.Compress();

    }

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

// CIpSecSadbHandler::AddCompletedL

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

//   

void CIpSecSadbHandler::AddCompletedL( TInt aError )

    {

    // No use to continue if failure occured

    if ( aError != KErrNone )

	    {

	    SAsAddedL( EFalse );

	    }

	switch ( iState )

	    {

	    case EAvailable:

	        {

	        // 1. Inbound  spi_us: port_us <- port_pc

             // Note: Family is KAfInet

        	iLocalAddress.SetPort( iSaParams->iPort_us );

        	iRemoteAddress.SetPort( iSaParams->iPort_pc );

	        AddSaL( iRemoteAddress, iLocalAddress, iSaParams->iSpi_us );

	        iState = EAddingInbound1;

	        break;

	        }

	    case EAddingInbound1:

	        {

	        // 2. Inbound  spi_uc: port_uc <- port_ps

	        iLocalAddress.SetPort( iSaParams->iPort_uc );

	        iRemoteAddress.SetPort( iSaParams->iPort_ps );

	        AddSaL(  iRemoteAddress, iLocalAddress, iSaParams->iSpi_uc );

	        iState = EAddingInbound2;

	        break;

	        }

	    case EAddingInbound2:

	        {

	        // 3. Outbound spi_ps: port_uc -> port_ps

	        iLocalAddress.SetPort( iSaParams->iPort_uc );

	        iRemoteAddress.SetPort( iSaParams->iPort_ps );

	        AddSaL( iLocalAddress, iRemoteAddress, iSaParams->iSpi_ps );

	        iState = EAddingOutbound1;

	        break;

	        }

	    case EAddingOutbound1:

	        {

	       	// 4. Outbound spi_pc: port_us -> port_pc

        	iLocalAddress.SetPort( iSaParams->iPort_us );

        	iRemoteAddress.SetPort( iSaParams->iPort_pc );

	        AddSaL( iLocalAddress, iRemoteAddress, iSaParams->iSpi_pc );

	        iState = EAddingOutbound2;

	        break;

	        }

	    case EAddingOutbound2:

	        {

	        iState = EAvailable;

	        SAsAddedL( ETrue );

	        break;

	        }

	    default:

	        {

	        break;

	        }

	    }

    }

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

// CIpSecSadbHandler::DeleteCompletedL

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

//      

void CIpSecSadbHandler::DeleteCompletedL()

    {

   	switch ( iState )

	    {

	    case EAvailable:

	        {

	        // 1. Inbound  spi_us: port_us <- port_pc

            // Note: Family is KAfInet

        	iLocalAddress.SetPort( iSaParams->iPort_us ); 

        	iRemoteAddress.SetPort( iSaParams->iPort_pc );

	        DeleteSaL( iRemoteAddress, iLocalAddress, iSaParams->iSpi_us );

	        iState = EDeletingInbound1;

	        break;

	        }

	    case EDeletingInbound1:

	        {

	        // 2. Inbound  spi_uc: port_uc <- port_ps

	        iLocalAddress.SetPort( iSaParams->iPort_uc );

	        iRemoteAddress.SetPort( iSaParams->iPort_ps );

	        DeleteSaL( iRemoteAddress, iLocalAddress, iSaParams->iSpi_uc );

	        iState = EDeletingInbound2;

	        break;

	        }

	    case EDeletingInbound2:

	        {

	        // 3. Outbound spi_ps: port_uc -> port_ps

	        iLocalAddress.SetPort( iSaParams->iPort_uc );

	        iRemoteAddress.SetPort( iSaParams->iPort_ps );

	        DeleteSaL( iLocalAddress, iRemoteAddress, iSaParams->iSpi_ps );

	        iState = EDeletingOutbound1;

	        break;

	        }

	    case EDeletingOutbound1:

	        {

	       	// 4. Outbound spi_pc: port_us -> port_pc

        	iLocalAddress.SetPort( iSaParams->iPort_us );

        	iRemoteAddress.SetPort( iSaParams->iPort_pc );

	        DeleteSaL( iLocalAddress, iRemoteAddress, iSaParams->iSpi_pc );

	        iState = EDeletingOutbound2;

	        break;

	        }

	    case EDeletingOutbound2:

	        {

	        // All done, inform observer.

	        // Might lead to destruction of this handler.

	        Reset();

	        iObserver.SAsDeletedL();

	        break;

	        }

	    default:

	        {

	        break;

	        }

	    }

    }

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

// CIpSecSadbHandler::AddSaL

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

//	

void CIpSecSadbHandler::AddSaL( 

    TInetAddr& aSourceAddress,

    TInetAddr& aDestinationAddress,

    TUint aSpi )

	{

	TUint seqNum( iParams->SeqNumber() );

	// Store sequence numbers of add operations

	User::LeaveIfError( iOngoingAdds.Append( seqNum ) );

	TPfkeySendMsg*

		msg = new ( ELeave ) TPfkeySendMsg( SADB_ADD, SADB_SATYPE_ESP, 

		   							  	    seqNum, PID );

	CleanupStack::PushL( msg );

	// SPI has to be converted to network byte order

	TUint32 spi = ConvertToBigEndian( aSpi );

	msg->Add( Int2Type<SADB_EXT_SA>(), spi, iSaParams->iAuthAlg, SADB_EALG_NULL, 

			  SADB_SASTATE_MATURE, 0,0 ); 

	msg->Add( Int2Type<SADB_EXT_ADDRESS_SRC>(), aSourceAddress, 0, 0 );

	msg->Add( Int2Type<SADB_EXT_ADDRESS_DST>(), aDestinationAddress, 0, 0 );	

	msg->Add( Int2Type<SADB_EXT_KEY_AUTH>(), iSaParams->iAuthKey, 0 );

	sadb_msg &m = msg->MsgHdr();

	m.sadb_msg_len = static_cast<TUint16>( msg->Length() / KWordLen );

	iSaDbMsgSender->SendL( msg, SADB_ADD );

	CleanupStack::Pop( msg ); // msg ownership was transferred

	}

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

// CIpSecSadbHandler::DeleteSaL

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

//				     

void CIpSecSadbHandler::DeleteSaL( 

    TInetAddr& aSourceAddress,

    TInetAddr& aDestinationAddress,

    TUint aSpi )

	{

	TPfkeySendMsg*

		msg = new ( ELeave ) TPfkeySendMsg( SADB_DELETE, SADB_SATYPE_ESP, 

		   							  	    iParams->SeqNumber(), PID );

	CleanupStack::PushL( msg );

    // SPI has to be converted to network byte order

	TUint32 spi = ConvertToBigEndian( aSpi );

	msg->Add( Int2Type<SADB_EXT_SA>(), spi, 0, 0, 

			  SADB_SASTATE_MATURE, 0,0 ); 

	msg->Add( Int2Type<SADB_EXT_ADDRESS_SRC>(), aSourceAddress, 0, 0 );

	msg->Add( Int2Type<SADB_EXT_ADDRESS_DST>(), aDestinationAddress, 0, 0 );

	sadb_msg &m = msg->MsgHdr();

	m.sadb_msg_len = static_cast<TUint16>( msg->Length() / KWordLen );

	iSaDbMsgSender->SendL( msg, SADB_DELETE );

	CleanupStack::Pop( msg ); // msg ownership was transferred	

	}

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

// CIpSecSadbHandler::SAsAddedL

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

//	

void CIpSecSadbHandler::SAsAddedL( TBool aSuccess )

    {

    // Haven't necassarily yet received all the sadb messages related

    // to add operations. In that case we have to wait for them since they

    // contain also information about success.

    if ( !aSuccess || ( iOngoingAdds.Count() == 0 && iState == EAvailable ) )

        {

        iObserver.SAsAddedL( aSuccess );

        Reset();

        }

    }

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

// CIpSecSadbHandler::ConvertToBigEndian

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

//		

TUint32 CIpSecSadbHandler::ConvertToBigEndian( TUint32 aNum )

    {

    const TInt KMaxTUint32CStringLen = 11;

    TUint8 temp[ KMaxTUint32CStringLen ];	

	LittleEndian::Put32( temp, aNum );

	return BigEndian::Get32( temp );

    }

// End of File