// 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:
// cache.cpp - the record cache
//

// This file contains the implementations of the CDndCache object.
#include "engine.h"
#include "node.h"
#include "cache.h"
#include <networking/dnd_err.h>
#include "inet6log.h"

// Cache root node for a specific name space
class CDndNameSpace : public CDndNode
	{
public:
	CDndNameSpace(TUint32 aNameSpaceId) : CDndNode(NULL, 0, _L8("")), iNameSpaceId(aNameSpaceId), iState(1) {}
	~CDndNameSpace();
	const TUint32 iNameSpaceId;	//< The name space ID
	TInt iState;				//< Address state (initially = 1)
	TInetAddr iAddr;			//< Server Address and port (if any)
	CDndNameSpace *iNext;		//< Next name space root
	};

/**
// The destructor has really nothing functional to do.
// The precondition for destruct is that ALL nodes and
// records under the root node have already been destroyed.
*/
CDndNameSpace::~CDndNameSpace()
	{
	ASSERT(IsEmpty());
	}


// CDndCache::CDndCache
// ********************
CDndCache::CDndCache()
	{}


// CDndCache::ContstructL
// **********************
void CDndCache::ConstructL()
	{
	LOG(Log::Printf(_L("CDndCache::ConstructL() size=%d\r\n"), (TInt)sizeof(*this)));
	}


// CDndCache::~CDndCache
// *********************
/**
// Delete ALL records, and as a side effect all nodes
// (except the roots are freed). And, then delete all
// root nodes.
//
// If there are locked records, which prevent deletion
// of all nodes, then cache destructor has been called
// incorrectly! (=> ~CDndNameSpace() will panic)
*/
CDndCache::~CDndCache()
	{
	iRecordList.Cleanup(0);		// Delete all unlocked records
	//
	// Delete (now supposedly empty) root nodes
	//
	while (iRootList)
		{
		CDndNameSpace *ns = iRootList;
		iRootList = iRootList->iNext;
		delete ns;
		}
	}

// CDndCache::Flush
// ****************
/**
// Empty the cache.
*/
void CDndCache::Flush()
	{
	iRecordList.Cleanup(0);
	}

// CDndCache::GetServerAddress
// ***************************
/**
// Get currently known server address for the name space.
//
// The address state is inially 1 (> 0). It is only changed by the
// CDndCache::SetServerAddress .
//
// If the name-space does not have a root node, the root node
// is created by this call (CDndCache::GetNameSpaceL).
//
// @param	aNameSpace	the name space id
// @retval	aAddr		the server address currently associated with the name space
// @returns	the state of the returned address as:
//	@li	> 0, no address has been set
//	@li	= 0, address set
//	@li < 0, address set with error state, or
//	@li	KErrNoMemory, if needed to create the root node and failed
*/
TInt CDndCache::GetServerAddress(const TUint32 aNameSpace, TInetAddr &aAddr)
	{
	CDndNameSpace *const ns = GetNameSpace(aNameSpace);
	if (ns == NULL)
		return KErrNoMemory;

	aAddr = ns->iAddr;
	return ns->iState;
	}

// CDndCache::SetServerAddress
// ***************************
/**
// Set the server address/state for the name space.
//
// If the name-space does not have a root node, the root node
// is created by this call (CDndCache::GetNameSpaceL).
//
// @param	aNameSpace	the name space id
// @param	aAddr		the server address to be set
// @param	aState		the state of the address
*/
void CDndCache::SetServerAddress(const TUint32 aNameSpace, const TInetAddr &aAddr, const TInt aState)
	{
	CDndNameSpace *const ns = GetNameSpace(aNameSpace);
	if (ns != NULL)
		{
		ns->iAddr = aAddr;
		ns->iState = aState;
		}
	}

// CDndCache::GetNameSpace
// ***********************
/**
// Locate the name space root or try to create it if not found.
//
// @param	aNameSpace	the name-space id
// @returns	the name-space root or NULL, if not found and create
//			failed.
*/
CDndNameSpace *CDndCache::GetNameSpace(const TUint32 aNameSpace)
	{
	CDndNameSpace *ns = iRootList;

	// Does a request namespace already exist?
	for ( ; ns != NULL; ns = ns->iNext)
		if (ns->iNameSpaceId == aNameSpace)
			return ns;

	// Does not exist, a new namespace needed, create a new root
	ns = new CDndNameSpace(aNameSpace);
	if (ns)
		{
		ns->iNext = iRootList;
		iRootList = ns;
		}
	return ns;
	}


// CDndCache::FindL
// ****************
/**
// Find record from the cache.
//
// Finds the record from the cache which 
// matches the name, type and class. If it has expired, it is invalidated
// and returned. If no such record exists, one new record is inserted and
// returned.
//
// If the name-space does not have a root node, the root node
// is created by this call (CDndCache::GetNameSpaceL).
//
// @param	aNameSpace
//		the name-space id. If ZERO, only search is performed
//		across all currently existing name-spaces. No new
//		state is created.
// @param	aName
//		the fully qualified domain-name which owns the record (dotted format)			
// @param	aType
//		the record type
// @param	aClass
//		the record class
// @param	aReqTime
//		the time of the request. This is used to detect records whose TTL
//		is expired
// @returns
//		always a non-NULL pointer to the record matching (aNameSpace,aName,aType,aClass). The FindL
//		will create the necessary node structures, if they do not exist before the call. If the
//		record didn't exist before, the initial state of the new record is "Invalid".
// @exception	KErrNoMemory
//		the main potential reason for FindL to fail (not enough memory to create the objects)
// @exception	KErrDndNoRecord
//		can occur only when called with aNameSpace == 0, and the record does not exist.
*/
CDndRecord * CDndCache::FindL(const TUint32 aNameSpace, const TDesC8 &aName, const EDnsQType aType, const EDnsQClass aClass, 
								const TTime &aReqTime)
	{
	CDndRecord *record = NULL;

	if (aNameSpace == 0)
		{
		// If no name space is specified, then just search for match, never add record
		for (CDndNameSpace *ns = iRootList; ; ns = ns->iNext)
			{
			if (ns == NULL)
				User::Leave(KErrDndNoRecord);
			record = ns->FindL(aName, FALSE, aType, aClass, iRecordList, aReqTime);
			if (record)
				break;
			}
		// record != NULL here, ALWAYS!
		}
	else
		{
		// When namespace is defined, always create the record and other necessary structures
		// if neeeded.
		//
		iRecordList.Cleanup(KDndMaxRecords);
		// Locate or create the name-space root
		CDndNameSpace *const ns = GetNameSpace(aNameSpace);
		if (ns == NULL)
			User::Leave(KErrNoMemory);
		// Locate (or create) the matching record
		record = ns->FindL(aName, TRUE, aType, aClass, iRecordList, aReqTime);
		// record != NULL here ALWAYS!
		}

	record->HitLRU();
	return record;
	}


#ifdef _LOG
// CDndCache::Dump
// ***************
/**
// Print out the entire cache (for DEBUG only)
*/
void CDndCache::Dump(CDndEngine &aControl)
	{
	if (!iRootList)
		aControl.ShowText(_L("No cache in the system"));
	else
		for (CDndNameSpace *ns = iRootList; ns != NULL; ns = ns->iNext)
			ns->Print(aControl);
	}
#endif