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

// key_msg.cpp - IPv6/IPv4 IPSEC PFKEY messages

// This module contains the main entry points for the

// implementations of the PFKEY messages, currently:

// SADB_GETSPI		CProtocolKey::ExecGetSPI

// SADB_UPDATE		CProtocolKey::ExecUpdate

// SADB_ADD		CProtocolKey::ExecAdd

// SADB_DELETE		CProtocolKey::ExecDelete

// SADB_GET		CProtocolKey::ExecGet

// SADB_ACQUIRE	CProtocolKey::ExecAcquire

// SADB_REGISTER	CProtocolKey::ExecRegister

// SADB_EXPIRE		(only sent to clients by IPsec)

// SADB_FLUSH		CProtocolKey::ExecFlush

// SADB_DUMP		CProtocolKey::ExecDump

// This module belongs to CProtocolKey implementation

// Common to all methods

// Return

// the request was syntactically correct and the

// ultimate success or failur can be checked from

// the reply PFKEY message (to all interested

// listeners).

// the request has some fatal flaws (programming

// errors). No PFKEY reply message is generated and

// the issuing socket write should indicate a failed

// operation to the application.

// The Base sadb_msg_errno field of the reply PFKEY message

// contains the ultimate result of the operation, again using

// the EPOC32 error codes. However, as the field is declared

// as "unsigned char", a positive value is stored in every

// case, that is for example "-KErrAlreadyExists". That is,

// this implementation makes a hidden assumption that KErrNone

// is ZERO, and all other errors that get used have a negative

// value! (the reserved field is now used to store extra 16

// bits of the error).

// Each ExecNNN method gets the same three parameters, even

// though not all need them all

// can be modified (a copy

// of the original and already

// linked to aMsg)

//

/**

 @file key_msg.cpp

 @code

 @endcode

 @li		KErrNone

 @li		!= KErrNone

 @li		TPfkeyMessage &aMsg		- the message to be acted

 @li		struct sadb_msg &aBase	- a working BASE part that

 @li		CProviderKey *aSrc		- the originating SAP

*/

#include "sadb.h"

#include "sa_crypt.h"

#include <networking/pfkeyv2.h>

#include "pfkey.h"

#include "pfkeymsg.h"

static void Update(struct sadb_msg &aBase, CSecurityAssoc &aSa, TPfkeyMessage &aMsg, MAssociationManager &aManager, CIpsecCryptoManager *aCrypto)

	/**

	* Update SA without leaving.

	*

	* Implement a local help function for the SA Update, which is not leaving.

	*

	* @param aBase	The writable copy of the base part of PFKEY message.

	* @param aMsg	The PFKEY message

	* @param aSa	The Security Association to update

	* @param aManager The manager of assocaitions

	* @param aCrypto The crypto library manager

	*/

	{

	TRAPD(ret, ret = aSa.UpdateL(aManager, aMsg, aCrypto));

	// PFKEY official error field is only 8 bits. Normal EPOC errors will usually

	// fit this space, when treated as small positive integers. However, IPSEC and

	// other components may return much bigger numbers. As suggested by Craig Metz,

	// the low order 8 bits of the error code are placed to the official field,

	// and the next 16 bits into the unused portion of the base structure. This

	// may give some breathing space, until the full 32 bit error can be fit into

	// the base structure...

	ret = -ret;				// Turn error number into positive number

	aBase.sadb_msg_errno = (TUint8)ret;

	aBase.sadb_msg_reserved = (TUint16)(ret >> 8);

	if (aMsg.iTs.iExt)

		aMsg.iTs.iTS = &aSa.iTS;

	}

CSecurityAssoc *CProtocolKey::FindEgg

	(

	CSecurityAssoc *sa,

	const TPfkeyMessage &aMsg,

	const struct sadb_msg &aBase

	)

	/**

	* Find the "Egg SA".

	*

	* A very local utility function to check if a iHash[i] chain

	* contains a matching "Egg" SA. This is not a general function,

	* ot has very specific preconditions (iDstAddr) etc, This is

	* more like inline macro, just coded to make code shorter.

	*

	* @param sa	The first sa to check

	* @param aMsg PFKEYv2 message to identify the Egg.

	* @param aBase The base part of the PFKEYv2 message.

	* @return NULL, if not found, and SA pointer, if found

	*/

	{

	const TIpAddress &dst = aMsg.iDstAddr.iAddr();

	for ( ; sa != NULL; sa = sa->iNext)

		if (sa->iSPI == 0 &&

			sa->iSendSeq == aBase.sadb_msg_seq &&

			sa->iType == aBase.sadb_msg_satype &&

			sa->iDst() == dst)

			break;	// Found!!

	return sa;

	}

void CProtocolKey::DumpSA

	(TPfkeyMessage &aMsg, struct sadb_msg &aBase, CProviderKey *aDst, CSecurityAssoc *sa)

	/**

	* Dump SA information into requesting socket.

	*

	* Build PFKEY message from the specified SA and deliver (CProtocolKey::Deliver())

	* it to the requesting socket (SAP). The keying information is never returned

	* this way.

	*

	* @param aMsg The PFKEY message to use

	* @param aBase The base part of the message.

	* @param aDst The requesting socket

	* @param sa The Security Assocication.

	*/

	{

	T_sadb_sa xSa

		(

		sa->iSPI,

		sa->iReplayCheck ? KMaxReplayWindowLength : 0,

		sa->iState,

		sa->iAalg,

		sa->iEalg,

		sa->iFlags);

	aMsg.iSa.iExt = &xSa;

	T_sadb_lifetime xCurrent(sa->iCurrent);

	aMsg.iCurrent.iExt = &xCurrent;

	T_sadb_lifetime xHard(SADB_EXT_LIFETIME_HARD, sa->iHard, sa->iCurrent);

	aMsg.iHard.iExt = &xHard;

	T_sadb_lifetime xSoft(SADB_EXT_LIFETIME_SOFT, sa->iSoft, sa->iCurrent);

	aMsg.iSoft.iExt = &xSoft;

	T_sadb_address xDst(SADB_EXT_ADDRESS_DST, sa->iInfo.iProtocol);

	aMsg.iDstAddr.iExt = &xDst;

	aMsg.iDstAddr.iAddr = sa->iDst;

	aMsg.iDstAddr.iPort = sa->iInfo.iPortDst;

	T_sadb_address xSrc(SADB_EXT_ADDRESS_SRC, sa->iInfo.iProtocol);

	if (!sa->iSrc().IsNone())

		{

		aMsg.iSrcAddr.iExt = &xSrc;

		aMsg.iSrcAddr.iAddr = sa->iSrc;

		aMsg.iSrcAddr.iPort = sa->iInfo.iPortSrc;

		}

	TIpAddress xProxyAddr(KInet6AddrNone, sa->TunnelIndex());

	T_sadb_address xProxy(SADB_EXT_ADDRESS_PROXY, sa->iInfo.iProtocol);

	if (!sa->iInfo.iSrc().IsNone())

		{

		aMsg.iProxyAddr.iExt = &xProxy;

		aMsg.iProxyAddr.iAddr = sa->iInfo.iSrc;

		}

	else if (xProxyAddr.iScope)

		{

		aMsg.iProxyAddr.iExt = &xProxy;

		aMsg.iProxyAddr.iAddr.Open(iEndPointCollection, xProxyAddr);

		}

	T_sadb_ident xSrcId(SADB_EXT_IDENTITY_SRC);

	if (sa->iInfo.iSrcIdentity)

		{

		// Build Source Identity Extension for the PFKEY

		aMsg.iSrcIdent.iExt = &xSrcId;

		aMsg.iSrcIdent.iData.Set(sa->iInfo.iSrcIdentity->Identity());

		xSrcId = T_sadb_ident(SADB_EXT_IDENTITY_SRC, aMsg.iSrcIdent.iData.Length());

		xSrcId.sadb_ident_type = sa->iInfo.iSrcIdentity->Type();

		}

	T_sadb_ident xDstId(SADB_EXT_IDENTITY_DST);

	if (sa->iInfo.iDstIdentity)

		{

		// Build Destination Identity Extension for the PFKEY

		aMsg.iDstIdent.iExt = &xDstId;

		aMsg.iDstIdent.iData.Set(sa->iInfo.iDstIdentity->Identity());

		xDstId = T_sadb_ident(SADB_EXT_IDENTITY_DST, aMsg.iDstIdent.iData.Length());

		xDstId.sadb_ident_type = sa->iInfo.iDstIdentity->Type();

		}

	T_sadb_ident xSrcEp(SADB_X_EXT_ENDPOINT_SRC);

	if (sa->iSrc.IsNamed())

		{

		// Build Source End Point Extension for the PFKEY

		aMsg.iSrcEndpoint.iExt = &xSrcEp;

		aMsg.iSrcEndpoint.iData.Set(sa->iSrc.Name());

		xSrcEp = T_sadb_ident(SADB_X_EXT_ENDPOINT_SRC, aMsg.iSrcEndpoint.iData.Length());

		}

	T_sadb_ident xDstEp(SADB_X_EXT_ENDPOINT_DST);

	if (sa->iDst.IsNamed())

		{

		// Build Destination End Point Extension for the PFKEY

		aMsg.iDstEndpoint.iExt = &xDstEp;

		aMsg.iDstEndpoint.iData.Set(sa->iDst.Name());

		xDstEp = T_sadb_ident(SADB_X_EXT_ENDPOINT_DST, aMsg.iDstEndpoint.iData.Length());

		}

	T_sadb_ts xTs(sa->iTS.Count());

	if (xTs.sadb_x_ts_numsel)

		{

		aMsg.iTs.iExt = &xTs;

		aMsg.iTs.iTS = &sa->iTS;

		}

	aBase.sadb_msg_satype = sa->iType;

	aBase.sadb_msg_len = aMsg.Length64();

	aDst->Deliver(aMsg);

	LOG(aMsg.LogPrint(_L("---->"), iCrypto->Algorithms()));

	// Can't leave pointers hanging.. clear them

	aMsg.iSa.iExt = NULL;

	aMsg.iCurrent.iExt = NULL;

	aMsg.iHard.iExt = NULL;

	aMsg.iSoft.iExt = NULL;

	aMsg.iSrcAddr.iExt = NULL;

	aMsg.iSrcAddr.iAddr.Close();

	aMsg.iDstAddr.iExt = NULL;

	aMsg.iDstAddr.iAddr.Close();

	aMsg.iProxyAddr.iExt = NULL;

	aMsg.iProxyAddr.iAddr.Close();

	aMsg.iSrcIdent.iExt = NULL;

	aMsg.iDstIdent.iExt = NULL;

	aMsg.iSrcEndpoint.iExt = NULL;

	aMsg.iDstEndpoint.iExt = NULL;

	aMsg.iTs.iExt = NULL;

	}

TInt CProtocolKey::ExecGetSPI

	(TPfkeyMessage &aMsg, struct sadb_msg &aBase, CProviderKey * /*aSrc*/)

	/**

	* GetSPI -- allocate next free SPI number for incoming SA

	*

	* @param aMsg The PFKEY message to process.

	* @param aBase Modifiable copy of the base extension.

	* @param aSrc The originating socket

	*/

	{

	// base, address, SPI range

	if (aMsg.iDstAddr.iExt == NULL ||

		aMsg.iSpirange.iExt == NULL ||

		aMsg.iSpirange.iExt->sadb_spirange_max <

			aMsg.iSpirange.iExt->sadb_spirange_min)

		return KErrGeneral;

	const int i = Hash(aMsg.iDstAddr.iAddr(), aBase.sadb_msg_satype);

	TUint32 spi = aMsg.iSpirange.iExt->sadb_spirange_min;

	if (!spi)

		spi++;		// Do not allow a request for SPI=0, this

					// value is used internally to mark "eggs"

					// (SA's acting as ACQUIRE request queue)!

	// Locate an unused SPI value within the requested range

	T_sadb_sa xsa(ByteOrder::Swap32(spi));

	CSecurityAssoc *sa = iHash[i];

	while (sa)

		{

		if (sa->iType == aBase.sadb_msg_satype &&

			sa->iDst() == aMsg.iDstAddr.iAddr() &&

			sa->iSPI == xsa.sadb_sa_spi)

			{

			// The spi is already in use, try next one in range

			if (xsa.sadb_sa_spi < aMsg.iSpirange.iExt->sadb_spirange_max)

				{

				xsa.sadb_sa_spi = ByteOrder::Swap32(++spi);

				sa = iHash[i];	// Restart search (might consider ordering

								// this list by SPI value, perhaps?)

								// *Don't reorder, unless something is

								// also done to support the current

								// ACQUIRE, which uses the current ordering

								// as a "feature" (check KEY_SA.CPP Acquire!)

								// -- msa

				continue;

				}

			break;	// --> Already Exists error!

			}

		else

			sa = sa->iNext;

		}

	if (sa)

		// Requested SPI could not be allocated

		aBase.sadb_msg_errno = -KErrAlreadyExists;

	else

		{

		if (aBase.sadb_msg_pid == 0 &&

			(sa = FindEgg(iHash[i], aMsg, aBase)) != NULL)

			{

			// This GETSPI is a reply to earlier kernel originated ACQUIRE,

			// locate the matching larval (egg) SA from the SAD.

			// (With current implementation this should really not happen,

			// as the Egg is for outgoing direction, and assigning SPI to

			// it at this end is somewhat dubious...

			//

			// However, could this branch be taken when the dst is multicast,

			// localhost or some other own address? Thus, leave code in just

			// in case -- msa

			sa->iSPI = xsa.sadb_sa_spi;

			sa->iSendSeq = 0;

			}

		else

			{

			// Application just requested an SPI value, need to create a larval

			// SA to hold this assigned value.

			// A problem? if application doesn't do update within timelimit, the

			// SA is expired and spi may get allocated to someone else. How to

			// verify that this "old" application doesn't have access to it anymore?

			// Have a SAP stored in larval SA? And, allow UPDATE only from this SAP?

			// Delete larval SA's if the owning SAP dies?

			aMsg.iSa.iExt = &xsa;

			sa = new CSecurityAssoc(aMsg);

			if (sa)

				{

				sa->iNext = iHash[i];

				iHash[i] = sa;

				}

			else

				aBase.sadb_msg_errno = -KErrNoMemory;

			}

		//

		// Add Association Extension to the PFKEY

		// Reply Message (SA(*))

		//

		aMsg.iSa.iExt = &xsa;

		aBase.sadb_msg_len = aMsg.Length64();

		}

	//

	// Report GETSPI to all interested listeners

	//

	Deliver(aMsg);

	return sa ? sa->TimerInit(*this) : KErrNone;

	}

TInt CProtocolKey::ExecUpdate

	(TPfkeyMessage &aMsg, struct sadb_msg &aBase, CProviderKey * /*aSrc*/)

	/**

	* Update existing SA.

	*

	* Uses PFKEY extensions:

	* base, SA, (lifetime(HSC)), address(SD), (address(P)), key(AE),

	*		(identify(SD), (sensitivity)

	*

	* @param aMsg The PFKEY message to process.

	* @param aBase Modifiable copy of the base extension.

	* @param aSrc The originating socket

	*/

	{

	if (aMsg.iDstAddr.iExt == NULL ||

		aMsg.iSa.iExt == NULL)

		return KErrGeneral;

	TInt i;

	CSecurityAssoc *sa =

		Lookup(aBase.sadb_msg_satype, aMsg.iSa.iExt->sadb_sa_spi, aMsg.iDstAddr.iAddr(), i);

	if (sa)

		Update(aBase, *sa, aMsg, *this, iCrypto);

	else if (aBase.sadb_msg_pid == 0 &&

			 (sa = FindEgg(iHash[i], aMsg, aBase)) != NULL)

		{

		//

		// This ADD is a reply to earlier kernel originated ACQUIRE,

		// Change the state from larval egg to real LARVAL state

		sa->iSendSeq = 0;

		Update(aBase, *sa, aMsg, *this, iCrypto);

		}

	else

		aBase.sadb_msg_errno = -KErrNotFound;

	//

	// Reply all Listeners

	//

	aMsg.iAuthKey.iExt = NULL;

	aMsg.iEncryptKey.iExt = NULL;

	aBase.sadb_msg_len = aMsg.Length64();

	Deliver(aMsg);

	return sa ? sa->TimerInit(*this) : KErrNone;

	}

TInt CProtocolKey::ExecAdd

	(TPfkeyMessage &aMsg, struct sadb_msg &aBase, CProviderKey * /*aSrc*/)

	/**

	* Add mew SA.

	*

	* Uses PFKEY extensions:

	* base, SA, (lifetime(HS)), address(SD), (address(P),) key(AE),

	*		(identity(SD),) (sensitivity)

	*

	* @param aMsg The PFKEY message to process.

	* @param aBase Modifiable copy of the base extension.

	* @param aSrc The originating socket

	*/

	{

	if (aMsg.iDstAddr.iExt == NULL ||

		aMsg.iSa.iExt == NULL ||

		aMsg.iSa.iExt->sadb_sa_state != SADB_SASTATE_MATURE)

		return KErrGeneral;

	CSecurityAssoc *sa;

	TInt i;

	sa = Lookup(aBase.sadb_msg_satype, aMsg.iSa.iExt->sadb_sa_spi, aMsg.iDstAddr.iAddr(), i);

	if (sa)

		aBase.sadb_msg_errno = -KErrAlreadyExists;

	else if (aBase.sadb_msg_pid == 0 &&

			 (sa = FindEgg(iHash[i], aMsg, aBase)) != NULL)

		{

		// This ADD is a reply to earlier kernel originated ACQUIRE,

		// Change the state from larval egg to real LARVAL state

		sa->iSendSeq = 0;

		Update(aBase, *sa, aMsg, *this, iCrypto);

		}

	else

		{

		// No matching SA exist yet, can create a new

		sa = new CSecurityAssoc(aMsg);

		if (sa)

			{

			Update(aBase, *sa, aMsg, *this, iCrypto);

			if(aBase.sadb_msg_errno == 0 && aBase.sadb_msg_reserved == 0 )

				{

				// *NOTE*

				//	Adding always front may have some useful semantics, It will

				//	make outbound traffic to use newest matching SA (see ACQUIRE

				//	processing).

				sa->iNext = iHash[i];

				iHash[i] = sa;

				}

			else

				{

				delete (sa);

				sa = NULL;

				}

			}

		else

			aBase.sadb_msg_errno = -KErrNoMemory;

		}

	// Return the message to all listeners

	// (Keying information removed, which changes the length and

	// thus the sadb_msg_len must be recomputed. The byte length

	// *should* already be divisible by 8, no roundup coded!!!)

	aMsg.iAuthKey.iExt = NULL;

	aMsg.iEncryptKey.iExt = NULL;

	aBase.sadb_msg_len = aMsg.Length64();

	Deliver(aMsg);

	return sa ? sa->TimerInit(*this) : KErrNone;

	}

TInt CProtocolKey::ExecDelete

	(TPfkeyMessage &aMsg, struct sadb_msg &aBase, CProviderKey * /*aSrc*/, TBool deliverMsg)

	/**

	* Delete an existing SA.

	*

	* Uses PKEFY extensions:

	* base, SA(*), address(SD)

	*

	* @param aMsg The PFKEY message to process.

	* @param aBase Modifiable copy of the base extension.

	* @param aSrc The originating socket

	* @param deliverMsg Value to determine whether or not to deliver the PFKEY 

	*                                   message to the listeners (ETrue by default). 

	*/

	{

	if (aMsg.iDstAddr.iExt == NULL ||

		aMsg.iSa.iExt == NULL)

		return KErrGeneral;

	TInt i;	// not used

	CSecurityAssoc *sa;

	sa = Lookup(aBase.sadb_msg_satype, aMsg.iSa.iExt->sadb_sa_spi, aMsg.iDstAddr.iAddr(), i);

	if (sa)

		Delete(sa);

	else

		aBase.sadb_msg_errno = -KErrNotFound;

	if (deliverMsg)

		Deliver(aMsg);

	return KErrNone;

	}

TInt CProtocolKey::ExecGet

	(TPfkeyMessage &aMsg, struct sadb_msg &aBase, CProviderKey *aSrc)

	/**

	* Get dump of specificic SA,

	*

	* Uses PKEFY extensions:

	* base, SA(*), address(SD)

	*

	* @param aMsg The PFKEY message to process.