// 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:

// dstcache.cpp - Destination cache implementation

// Destination cache implementation

//

/**

 @file dstcache.cpp

*/

#include <in6_dstcache.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <in6_dstcache_internal.h>

#endif

#ifdef NONSHARABLE_CLASS

	NONSHARABLE_CLASS(CDestinationCache);

#endif

class CDestinationCache : public MDestinationCache, public CBase

	{

public:

	CDestinationCache(TInt aKeyMode);

//	~CDestinationCache();  // No explicit destructor needed, as far as I see

	void ConstructL();

	virtual void StoreL(const TInetAddr &aAddr, TCacheInfo &aInfo);

	virtual const TCacheInfo *Find(const TInetAddr &aAddr);

	virtual void RemoveL(const TInetAddr &aAddr);

	virtual void SetL(const TInetAddr &aAddr, TUint aParIndex, TUint32 aValue);

	virtual void Cleanup();

	virtual inline void RemoveAll()

	{ iStorage.RemoveAll(); }

	virtual inline void SetLifetime(TUint aLifetime) { iLifetime = aLifetime; }

	virtual inline void SetMaxSize(TUint aMaxSize) { iMaxSize = aMaxSize; }

	friend TBool IfIsExpired(const TCacheInfo &aCinfo, void *aCachePtr);

	virtual TBool Match(const TInetAddr& aAddrA, const TInetAddr& aAddrB) const;

private:

	TBool IsExpired(const TCacheInfo &aCinfo) const;

	TCacheHash	iStorage;	//< Hash table that stores the destination cache entries

	TUint		iLifetime;	//< Lifetime of a destination cache entry (seconds)

	TUint		iMaxSize;	//< Maximum memory used for cache entries (bytes)

	TUint		iMemUsed;	//< Current total memory used by cache entries

	// Key Mode selected when instantiating this class

	THashKeyIp6::TKeyMode	iKeyMode;

	};

EXPORT_C MDestinationCache *MDestinationCache::CreateDstCache(TInt aKeyMode)

	{

	CDestinationCache *dcache = new CDestinationCache(aKeyMode);

	if (dcache)

		{

		TInt err = KErrNone;

		// coverity[leave_without_push]

		// if ConstructL() leaves, the leave code is trapped in "err" and proper cleanup is done by freeing the memory alocated to "dcache"

		TRAP(err, dcache->ConstructL());

		if (err != KErrNone)

			{

			delete dcache;

			dcache = NULL;

			}

		}

	return dcache;

	}

CDestinationCache::CDestinationCache(TInt aKeyMode) :	CBase(),

														iStorage(KCacheHashSize),

														iLifetime(KDstCacheLifetime),

														iMaxSize(KDstCacheMaxSize)

	{

	switch (aKeyMode)

		{

	case 2:

		iKeyMode = THashKeyIp6::EPerNet;

		break;

	default:

		iKeyMode = THashKeyIp6::EPerHost;

		break;

		// EPerIface not yet implemented		

		}

	}

void CDestinationCache::ConstructL()

	{

	iStorage.ConstructL();

	}

void CDestinationCache::StoreL(const TInetAddr &aAddr, TCacheInfo &aInfo)

	{

	aInfo.iStoreTime.UniversalTime();

	THashKeyIp6 k(iKeyMode, aAddr);

	// Check that hash size does not exceed the given limit.

	// If it is about to do so, clean up expired entries and try again.

	// If it still fails, StoreL fails.

	if (iMemUsed >= iMaxSize)

		{

		Cleanup();  // This reduces iMemUsed if there was expired entries

		if (iMemUsed >= iMaxSize)

			{

			User::Leave(KErrNoMemory);  // TODO: change error code

			}

		}

	// Check if there is a non-expired entry in the cache. If incoming aInfo has any

	// non-null entries, they replace the earlier cache entries. Entries that were

	// not updated with this call remain unmodified in the cache.

	// However, the store time is refreshed.

	TCacheInfo *oldent = iStorage.Find(k);

	if (oldent && !IsExpired(*oldent))

		{

		for (TUint i = 0; i < KNumCacheMetrics; i++)

			{

			if (aInfo.iMetrics[i] != 0)

				oldent->iMetrics[i] = aInfo.iMetrics[i];

			}

		oldent->iStoreTime.UniversalTime();

		return;  // Hash-store method is not needed this time.

		}

	TUint mem = iStorage.StoreL(k, aInfo);

	iMemUsed += mem;

	}

void CDestinationCache::SetL(const TInetAddr &aAddr, TUint aParIndex, TUint32 aValue)

	{

	TCacheInfo *infoptr;

	// Overwrite existing value if it exists, otherwise create a new entry in cache

	THashKeyIp6 k(iKeyMode, aAddr);

	infoptr = iStorage.Find(k);

	if (infoptr && !IsExpired(*infoptr))

		{

		infoptr->iMetrics[aParIndex] = aValue;

		infoptr->iStoreTime.UniversalTime();

		}

	else

		{

		TCacheInfo newinfo;

		newinfo.ClearAll();

		newinfo.iMetrics[aParIndex] = aValue;

		StoreL(aAddr, newinfo);

		}

	}

const TCacheInfo *CDestinationCache::Find(const TInetAddr &aAddr)

	{

	THashKeyIp6 k(iKeyMode, aAddr);

	TCacheInfo *cinfo = iStorage.Find(k);

	// Check whether the cache entry is recent enough. If not, return NULL.

	// However, we don't delete an expired entry from cache. It remains as a placeholder

	// for future equivalent entries.

	if (!cinfo || IsExpired(*cinfo))

		{

		return NULL;

		}

	return cinfo;

	}

void CDestinationCache::RemoveL(const TInetAddr &aAddr)

	{

	THashKeyIp6 k(iKeyMode, aAddr);

	TUint mem = iStorage.RemoveL(k);

	iMemUsed -= mem;

	}

// Same as CDestinationCache::IsExpired(), but this is to be used with RemoveIf() call.

TBool IfIsExpired(const TCacheInfo &aCinfo, void *aCachePtr)

	{

	if (!aCachePtr)

		{

		return EFalse;

		}

	return ((CDestinationCache *)aCachePtr)->IsExpired(aCinfo);

	}

void CDestinationCache::Cleanup()

	{

	iMemUsed -= iStorage.RemoveIf(IfIsExpired, this);

	}

TBool CDestinationCache::IsExpired(const TCacheInfo &aCinfo) const

	{

	TTime now;

	TTimeIntervalSeconds secs;

	now.UniversalTime();

	if (now.SecondsFrom(aCinfo.iStoreTime, secs) != KErrNone)

		{

		// Overflow or something. Consider it as expired entry.

		return ETrue;

		}

	if ((TUint)secs.Int() > iLifetime)

		{

		// Expired

		return ETrue;

		}

	return EFalse;

	}

TBool CDestinationCache::Match(const TInetAddr& aAddrA, const TInetAddr& aAddrB) const

	{

	THashKeyIp6 ka(iKeyMode, aAddrA);

	THashKeyIp6 kb(iKeyMode, aAddrB);

	return ka.IsEqual(kb);

	}

// --- THashTable methods ---

template <class K, class V>

THashTable<K,V>::THashTable(TUint aSize) : iTable(NULL), iSize(aSize)

	{

	}

template <class K, class V>

THashTable<K,V>::~THashTable()

	{

	RemoveAll();

	delete [] iTable;

	}

template <class K, class V>

void THashTable<K,V>::ConstructL()

	{

	iTable = new TChain<K,V>[iSize];

	if (!iTable)

		{

		User::Leave(KErrNoMemory);

		}

	for (TUint i = 0; i < iSize; i++)

		{

		iTable[i].iNext = NULL;

		}

	}

template <class K, class V>

TUint THashTable<K,V>::StoreL(MHashKey& aKey, V& aValue)

	{	

	if (!iTable)

		{

		User::Leave(KErrGeneral);

		}

	TUint memused = 0;

	TInt idx = aKey.ToInt() % iSize;

	TChain<K,V> *ptr = &iTable[idx], *newitem = NULL;

	while (ptr->iNext)

		{

		if (ptr->iNext->iKey.IsEqual(aKey))

			{

			// The conventional mode would be:

			//     User::Leave(KErrAlreadyExists)

			// ...however, due to the lazy garbage collection mode adopted, we overwrite

			// the existing entry

			newitem = ptr->iNext;

			break;

			}

		ptr = ptr->iNext;

		}

	// If the key wasn't stored earlier, allocate space for new data item.

	// Allocations from heap is not always a very popular idea, but these events are

	// expected to occur quite rarely.

	if (!newitem)

		{

		newitem = new(ELeave) TChain<K,V>;

		if (!newitem)

			{

			User::Leave(KErrNoMemory);

			}

		newitem->iKey = *((K*) &aKey);

		newitem->iNext = NULL;

		ptr->iNext = newitem;

		memused = sizeof(TChain<K,V>);

		}

	newitem->iValue = aValue;

	/* Dynamically allocated memory newitem has been assigned to ptr->iNext and managed through the list.

	So CleanupStack::PopAndDestroy() will deallocate that memory. But, Coverity has misinterpreted it an issue.*/

	// coverity [SYMBIAN.CLEANUP STACK]

	// coverity [memory_leak]

	return memused;

	}

template <class K, class V>

V* THashTable<K,V>::Find(MHashKey& aKey)

	{

	if (!iTable) return NULL;

	TInt idx = aKey.ToInt() % iSize;

	TChain<K,V> *ptr = &iTable[idx];

	while (ptr->iNext)

		{

		if (ptr->iNext->iKey.IsEqual(aKey))

			{

			return &ptr->iNext->iValue;

			}

		ptr = ptr->iNext;

		}

	// Not found

	return NULL;

	}

template <class K, class V>

TUint THashTable<K,V>::RemoveL(MHashKey& aKey)

	{

	if (!iTable)

		{

		User::Leave(KErrGeneral);

		}

	TInt idx = aKey.ToInt() % iSize;

	TChain<K,V> *ptr = &iTable[idx];

	while (ptr->iNext)

		{

		if (ptr->iNext->iKey.IsEqual(aKey))

			{

			TChain<K,V> *removed = ptr->iNext;

			ptr->iNext = removed->iNext;

			delete removed;

			return sizeof(TChain<K,V>);

			}

		}

	// Key was not found

	User::Leave(KErrNotFound);

	return 0;

	}

template <class K, class V>

TUint THashTable<K,V>::Length()

	{

	if (!iTable) return 0;

	TUint length = 0;

	for (TInt idx = 0; idx < iSize; idx++)

		{

		TChain<K,V> *ptr = &iTable[idx];

		while (ptr->iNext)

			{

			length++;

			ptr = ptr->iNext;

			}

		}

	return length;

	}

template <class K, class V>

TUint THashTable<K,V>::RemoveIf(	TBool (*aRemoveCriteria)(const V&, void *),

									void *aDataObject)

	{

	if (!iTable)

		{

		return 0;

		}

	TUint memfreed = 0;

	TChain<K,V> *ptr = NULL;

	for (TUint idx = 0; idx < iSize; idx++)

		{

		ptr = &iTable[idx];

		while (ptr->iNext)

			{

			if (aRemoveCriteria(ptr->iNext->iValue, aDataObject))

				{

				TChain<K,V> *removed = ptr->iNext;

				ptr->iNext = removed->iNext;

				delete removed;

				memfreed += sizeof(TChain<K,V>);				

				}

			ptr = ptr->iNext;

			}

		}

	return memfreed;

	}

template <class K, class V>

void THashTable<K,V>::RemoveAll()

	{

	if (iTable != NULL)

		{

		TChain<K,V> *ptr = NULL, *last = NULL;

		for (TUint i = 0; i < iSize; i++)

			{

			// Remember that the first chain entry in &iTable[i] does not contain data.

			// The data items start from the linked entries.

			ptr = &iTable[i];

			while (ptr)

				{

				ptr = ptr->iNext;

				if (last) delete last;

				last = ptr;

				}

			}

		}	

	}

THashKeyIp6::THashKeyIp6(TKeyMode aKeyMode, const TInetAddr& aAddr)

	{

	// TODO: retrieve key mode, and assign only a prefix instead of full address.

	// Simple prefix length is not enough, because I'd like to use the same cache for

	// both IPv4 and IPv6

	iKeyMode = aKeyMode;

	iAddress = aAddr.Ip6Address();

	iScopeId = aAddr.Scope();

	}

TUint THashKeyIp6::ToInt()

	{

	if (iKeyMode == EPerNet)

		{

		if (iAddress.IsV4Mapped())

			{

			// IPv4: Network is considered a /24

			return iAddress.u.iAddr32[3] >> 8;

			}

		else

			{

			// IPv6: Network is considered a /64.

			// Return the least significant 32 bits from the network part.

			return iAddress.u.iAddr32[1];

			}

		}

	else  // EPerHost and others (EPerIface not yet implemented)

		{

		// The least significant 32 bits is used as the int index

		return iAddress.u.iAddr32[3];

		}

	}

TBool THashKeyIp6::IsEqual(const MHashKey& aKey)

	{

	// casting is always risky business, but the user is required

	// to use this method properly

	const TIp6Addr addr2 = ((const THashKeyIp6&)aKey).Ip6Address();

	// If scope id is different, match will always fail

	// (until per interface mode is implemented)

	if (iScopeId != ((const THashKeyIp6&)aKey).ScopeId())

		{

		return EFalse;

		}

	if (iKeyMode == EPerNet)

		{

		TInt match = iAddress.Match(addr2);

		if (iAddress.IsV4Mapped() && match >= 96 + 24)

			{

			return ETrue;

			}

		else if (match >= 64)

			{

			return ETrue;

			}

		return EFalse;

		}

	else  // EPerHost and others (EPerIface not yet implemented)

		{

		return iAddress.IsEqual(addr2);

		}

	}