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

// epdb.cpp - IPSEC Endpoint Database implementation

// @internalComponent	for IPSEC

//

#include "sa_spec.h"

#include "ipaddress.h"

#include "epdb.h"

#include "ipseclog.h"

class CEndPoint : public CIpsecReferenceCountObject

	/**

	* Storage location for internet address with scope id.

	*

	* This object is always a member of some collection of

	* addresses via the RCircularList. The collection may

	* contain only this object. The membership in the

	* collection does not required reference counting -- when

	* object is deleted, it is removed from the collection

	* (and added to a collection containing only the self).

	*/

	{

protected:

	~CEndPoint();

public:

	CEndPoint(const TIp6Addr &aAddr, const TUint32 aScope);

	CEndPoint(RCircularList &aList, TUint aLength);

	static CEndPoint *New(RCircularList &aList, const TDesC &aName);

	static CEndPoint &Cast(RCircularList &aList);

	TBool MatchingName(const TDesC &aName);

	RCircularList iList;	//< Maintain a collection of addresses.

	TIpAddress iAddr;		//< Address and scope id.

	//

	// *WARNING* *WARNING* *WARNING*

	// What now follows, is the TLitC8 structure.

	// The extra space is allocated only, if iTypeLength

	// is non-zero.

	//

	// Why this TLitC8 "hack" instead of traditional

	// C construct with a "length" member and "fake buf[1]"?

	//

	// As far as layout, this is exactly the same. The TLitC8

	// "hack" only forces a Symbian specific layout. When a

	// descriptor is needed, it doesn't need to be constructed,

	// it's already existing and just returning a reference

	// to iTypeLength as TLitC8 is sufficient.

	//

	const TUint iTypeLength;

	inline const TDesC8 &Name() const { return ((TLitC8<1> &)iTypeLength)(); }

	inline TBool IsNamed() const { return iTypeLength != 0; }

	};

//

// CEndPoint implementation //

//

CEndPoint::CEndPoint(const TIp6Addr &aAddr, const TUint32 aScope) : iAddr(aAddr, aScope), iTypeLength(0)

	{

	}

CEndPoint::CEndPoint(RCircularList &aList, TUint aLength) : iTypeLength(aLength)

	{

	aList.Attach(iList);

	}

CEndPoint::~CEndPoint()

	{

	iList.Detach();

	}

CEndPoint &CEndPoint::Cast(RCircularList &aList)

	{

	return *((CEndPoint *)((char *)(&aList) - _FOFF(CEndPoint, iList)));

	}

CEndPoint *CEndPoint::New(RCircularList &aList, const TDesC &aName)

	{

	const TUint len = aName.Length();

	CEndPoint *ep = new (len) CEndPoint(aList, len);

	if (ep)

		{

		// See _LIT and TLitC for this initializer!!!

		TPtr8(&((TLitC8<1> &)ep->iTypeLength).iBuf[0], len).Copy(aName);

		}

	return ep;

	}

TBool CEndPoint::MatchingName(const TDesC &aName)

	/**

	* Test if the end point name matches.

	*

	* This is not simple compare, but

	*

	* - unnamed end point (name length == 0) does not match empty aName

	* - comparison is made only between lower 8 bits of each character (name should only contain ASCII!)

	*

	* @param aName The name to be compared.

	*/

	{

	TInt i = aName.Length();

	if (iTypeLength == 0 || (TUint)i != iTypeLength)

		return EFalse;

	const TText *s = aName.Ptr();

	const TText8 *p = Name().Ptr();

	while (--i >= 0)

		{

		if (s[i] != p[i])

			return EFalse;

		}

	return ETrue;

	}

//

// RIpAddress implementation //

//

RIpAddress::RIpAddress(const RIpAddress &aAddr)

	/**

	* Copy constructor.

	*

	* Update the reference count of the copied object.

	*/

	{

	if ((iAddr = aAddr.iAddr) != NULL)

		iAddr->Open();

	}

RIpAddress & RIpAddress::operator=(const RIpAddress &aAddr)

	/**

	* Assign operator.

	*

	* Close previous content and update the reference count

	* of the assigned object.

	*/

	{

	if (this != &aAddr)	// Only need do something if not assigning to self.

		{

		Close();

		if ((iAddr = aAddr.iAddr) != NULL)

			iAddr->Open();

		}

	return *this;

	}

RIpAddress::~RIpAddress()

	/**

	* Destructor is implicit Close.

	*/

	{

	Close();

	}

void RIpAddress::Close()

	/**

	* Detach address from the handle.

	*/

	{

	if (iAddr)

		{

		iAddr->Close();

		iAddr = NULL;

		}

	}

TInt RIpAddress::Open(REndPoints &aMgr, const TDesC &aName)

	/**

	* Find an existing named end point and attach.

	*

	* @param	aMgr	The EndPoint Collection

	* @param	aName	The EndPoint Name

	* 

	* @return KErrNone on success, and KErrNotFound if endpoint is not defined.

	*/

	{

	Close();	// Detach previous, if any present.

	TCircularListIter iter(aMgr);

	RCircularList *r;

	while ((r = iter++) != NULL)

		{

		CEndPoint &p = CEndPoint::Cast(*r);

		if (p.MatchingName(aName))

			{

			// An additional reference to an existing named

			// address, the reference count needs to be incremented.

			p.Open();

			iAddr = &p;

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

TInt RIpAddress::Open(REndPoints &aMgr, const TIpAddress &aAddr)

	/**

	* Find or create unnamed end point and attach.

	*

	* @param	aMgr	The EndPoint Collection

	* @param	aAddr	The EndPoint address

	*

	* @return	KErrNone when success, and KErrNoMemory if end point allocation fails.

	*/

	{

	Close();	// Detach previous, if any present.

	TCircularListIter iter(aMgr);

	RCircularList *r;

	while ((r = iter++) != NULL)

		{

		CEndPoint &p = CEndPoint::Cast(*r);

		// *note* currently TIpAddress == operator treats iScope==0 as

		// a wild card. That is not the correct semantic here.

		// The values need to match bit by bit..

		if (!p.IsNamed () && p.iAddr.IsEqual(aAddr) && p.iAddr.iScope == aAddr.iScope)

			{

			// An additional reference to an existing unnamed

			// address, the reference count needs to be incremented.

			p.Open();

			iAddr = &p;

			return KErrNone;

			}

		}

	// Create a new unnamed address. The initial reference

	// from the contruction corresponds to the RIpAddress

	// handle. The membership in the circular list is not

	// counted as a reference.

	iAddr = new CEndPoint(aMgr, 0);

	if (iAddr == NULL)

		return KErrNoMemory;

	iAddr->iAddr = aAddr;

	return KErrNone;

	}

TInt RIpAddress::Open(REndPoints &aMgr, const TInetAddr &aAddr)

	{

	TIpAddress addr(aAddr);

	return Open(aMgr, addr);

	}

TInt RIpAddress::Open(REndPoints &aMgr, const TDesC &aName, const TIpAddress &aAddr, TInt aOptional)

	/**

	* Find or create named end point and attach.

	*

	* Search for the named enpoint and attach it if found. If not found,

	* create a new end point into the end point collection.

	*

	* The aAddr is the initial value for the new end point. If the end

	* already exists, the content is changed to aAddr, if aOptional is

	* non-zero. Otherwise old end point content is not changed.

	*

	* @param	aMgr	The EndPoint Collection

	* @param	aName	The EndPoint Name

	* @param	aAddr	The new address of the end point (see aOptional)

	* @param	aOptional	Controls whether existing end point address is overwritten.

	*

	* @return	KErrNone if success, and KErrNoMemory if endpoint cannot be allocated.

	*/

	{

	if (Open(aMgr, aName) != KErrNone)

		{

		// Create a new named end point. The initial reference

		// from the contruction corresponds to the RIpAddress

		// handle. The membership in the circular list is not

		// counted as a reference.

		CEndPoint *p = CEndPoint::New(aMgr, aName);

		if (p == NULL)

			return KErrNoMemory;

		iAddr = p;

		aOptional = 0;

		}

	if (!aOptional)

		{

		iAddr->iAddr = aAddr;

		}

	return KErrNone;

	}

TInt RIpAddress::Set(const TIp6Addr &aAddr, TUint32 aScopeId)

	/**

	* Set content to given internet address.

	*

	* This cannot be used to change address content of an

	* existing named or internal end point. If there is an

	* existing CEndPoint which is shared by someone else

	* (reference count > 0 or a member of collection

	* with other objects), then this detaches from that

	* end point and allocates a new private CEndPoint

	* for the handle.

	*

	* This method is tailored for fast operation when

	* the address information from the packet or flow

	* needs to be packed into RIpAddress. By preallocating

	* this handle and never sharing the content, the

	* Set operation is a simple address copy and no

	* memory allocation.

	*

	* @param aAddr The raw IPv6 address

	* @param aScopeId The scope id of the address

	*

	* @return KErrNone or KErrNoMemory.

	*/

	{

	if (iAddr == NULL || iAddr->IsShared())

		{

		// The End Point does not exist, or is shared in some way. Need to

		// allocate a new object for this handle.

		Close();		// Release previous object.

		iAddr = new CEndPoint(aAddr, aScopeId);

		if (iAddr == NULL)

			return KErrNoMemory;

		}

	else

		{

		if (!iAddr->iList.IsDetached())

			{

			// The object is a member of non-empty collection. However,

			// because this reference is the only reference to it,

			// closing would only delete the object. Might as well

			// just detach it from the collection and reuse the

			// CEndPoint as is. [this is "just in case" branch --

			// the normal intended usage pattern should not make

			// CEndPoint of this handle to be a member of any

			// collection!]

			iAddr->iList.Detach();

			}

		iAddr->iAddr.SetAddress(aAddr, aScopeId);

		}

	return KErrNone;

	}

TInt RIpAddress::Set(const TInetAddr &aAddr)

	/**

	* Set content to given internet address.

	*

	* See the other Set.

	*

	* @param aAddr The internet address in IPv6 format.

	*/

	{

	return Set(aAddr.Ip6Address(), aAddr.Scope());

	}

const TIpAddress& RIpAddress::operator()() const

	/**

	* Returns a reference to the contained IP address.

	*

	* This reference is only valid as long as handle is open. It must not

	* be used after the handle is closed.

	*

	* Always succeeds, and returns all zeroes address, if handle is not open.

	*

	* @return	The Address.

	*/

	{

	// This is actually

	//		static const TIpAddress none;

	// but which cannot be used because TIpAddress has a constructor

	// and it would result "ipsec6.prt has initialized data" error

	// for target build.

	static const char none[sizeof(TIpAddress)] = {0 };

	return iAddr ? iAddr->iAddr : reinterpret_cast<const TIpAddress &>(none);

	}

TBool RIpAddress::IsNamed() const

	{

	return iAddr ? iAddr->IsNamed() : EFalse;	

	}

const TDesC8 &RIpAddress::Name() const

	{

	return IsNamed() ? iAddr->Name() : KNullDesC8();

	}

//

// REndPoints implementation //

//

//

// Debug only //

//

#ifdef _LOG

class TAddressBuf : public TBuf<70>

	{

public:

	TAddressBuf(const TIpAddress &aAddr);

	};

TAddressBuf::TAddressBuf(const TIpAddress &aAddr)

	{

	TInetAddr addr(aAddr, 0);

	addr.SetScope(aAddr.iScope);

	addr.OutputWithScope(*this);

	}

void REndPoints::LogPrint(const TDesC &aFormat) const

	/**

	* Print the current set of end points into IPSEC Log file.

	*

	* The format string must contain exactly two %S format

	* controls. The first is used for the name and the second

	* for the currently assigned address.

	*

	* @param aFormat	The print format.

	*/

	{	

	_LIT(KUnnamed, "<internal>");

	TCircularListIter iter(*this);

	RCircularList *r;

	while ((r = iter++) != NULL)

		{

		const CEndPoint &n = CEndPoint::Cast(*r);

		TAddressBuf addr(n.iAddr);

		if (n.IsNamed())

			{

			TBuf<100> name;

			name.Copy(n.Name());

			Log::Printf(aFormat, &name, &addr);		

			}

		else

			Log::Printf(aFormat, &KUnnamed(), &addr);

		}

	}

#endif