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

// node.cpp - structures to hold node information

// CDndNode object acts as a node in the tree that represents the cache for the DNS responses.

// TDndNodeList is a linked list of CDndNode objects.

//

#include "node.h"

#include "engine.h"

#include <networking/dnd_err.h>

#include "inet6log.h"

const TInt CDndNode::iOffset = _FOFF(CDndNode, iDlink);

// CDndNode::CDndNode

// ******************

CDndNode::CDndNode(CDndNode *const aParent, const TInt aLevel, const TNodeLabel &aLabel)

: iParent(aParent), iLevel(aLevel), iLabel(aLabel)

	{

	}

// CDndNode::~CDndNode

// *******************

CDndNode::~CDndNode()

	{

	//

	// Node can NEVER be deleted, if it has children or records!

	//

	__ASSERT_ALWAYS(IsEmpty(), User::Panic(_L("DND"), 0));

	}

// CDndNode::Cleanup

// *****************

/**

// Starting from current node, delete nodes in the path

// if they have no records and no children.

//

// Maintain the "cache invariant": whenever control is outside

// the cache implementation, the cache must not contain any

// nodes that have no child nodes and no records (with exception

// of the root nodes at level 0, iParent == NULL)

*/

void CDndNode::Cleanup()

	{

	CDndNode *current = this;

	while (current->iParent && current->IsEmpty())

		{

		CDndNode *parent = current->iParent;

		parent->DeleteNode(current);

		current = parent;

		}

	}

// CDndNode::DeleteNode

// ********************

void CDndNode::DeleteNode(CDndNode *const aNode)

	{

	iChildren.DeleteNode(aNode);

	}

// CDndNode::DeleteRecord

// **********************

/**

// This method must not be called by anyone else except the

// CDndRecord::Delete().

//

// The call will detach the record instance from this node,

// deletes the record instance, and also activates the

// cleanup, which deletes a path of nodes, if they have

// no records and no children. 

//

// @param	aRecord

//		specifies the record to be deleted. This record must

//		exist and be owned by the node 

*/

void CDndNode::DeleteRecord(CDndRecord *const aRecord)

	{

	iRecordList.Delete(aRecord);

	Cleanup();

	}

// CDndNode::FindL

// ***************

/**

// Split the dotted name into components labels and locate the

// node at the end of the path defined by those labels. The

// search starts from the current node. If necessary, the path

// is created (aFlag != 0).

//

// After the end node of the path is located (or created), a

// matching record is located (or created).

//

// @param	aName	defines the domain name

// @param	aFlag

//		if value is FALSE, only search is performed and a NULL returned if node

//		is not found. If value is TRUE, the necessary path and final node is

//		created, if they don't exist yet.

// @param	aType	the type of the record

// @param	aClass	the class of the record

// @param	aLRU	the LRU list into which the record will belong

//					(only used if record is created by this call).

// @param	aReqTime	the current time (of the query)

// @returns	a pointer to the newly created record

//	@li	NULL, if node does not exist (can only happen, if aFlag == 0!

//	@li	non-NULL pointer to the record matching the aName, aClass and aType

// @leave KErrNoMemory

//		The function leaves for non-recoverable error (out of memory).

//		Can occur only if aFlag != 0.

// @leave KErrDndBadQuery

//		The query name is not valid as DNS domain name.

*/

CDndRecord *CDndNode::FindL(const TDesC8 &aName, const TBool aFlag,

							const EDnsQType aType, const EDnsQClass aClass,

							TDndRecordLRU &aLRU, const TTime &aReqTime)

	{

	CDndNode *current = this;

	TPtrC8 remaining(aName);

	while (remaining.Length() > 0)

		{

		// extract the next name segment

		TPtrC8 currentLabel;

		TInt index = remaining.LocateReverse('.');

		if (index == KErrNotFound)

			{

			currentLabel.Set(remaining);

			index = 0;	// Desired node is reached

			}

		else

			{

			if (index <= 0)

				User::Leave(KErrDndBadQuery);	// a name starting with "." is not valid

			currentLabel.Set(remaining.Mid(index + 1));

			}

		if (currentLabel.Length() == 0)

			User::Leave(KErrDndBadQuery);			// bad name, empty labels "foo..bar" not legal!

		if (currentLabel.Length() > KDnsMaxLabel)	// this should be 63! (DNS hard limit)

			User::Leave(KErrDndBadQuery);

		CDndNode *node = current->iChildren.Find(currentLabel);

		if (node == NULL)

			{

			if (!aFlag)

				return NULL;	// Do not insert!

			node = new CDndNode(current, current->iLevel + 1, currentLabel);

			if (node == NULL)

				{

				current->Cleanup();

				User::Leave(KErrNoMemory);

				}

			current->iChildren.AddNode(*node);

			}

		remaining.Set(remaining.Left(index));

		current = node;

		}

	CDndRecord *record = current->iRecordList.Find(aType, aClass, aReqTime);

	if (!aFlag || record != NULL)

		return record;

	//

	// The looked record does not exist yet, create it here

	//

	record = new CDndRecord(aLRU, *current, aType, aClass);

	if (record == NULL)

		{

		// This may invalidate 'this' pointer, so careful here!

		current->Cleanup();

		User::Leave(KErrNoMemory);

		}

	else

		current->iRecordList.Add(*record);

	return record;

	}

#ifdef _LOG

// CDndNode::Print

// ***************

void CDndNode::Print(CDndEngine &aControl)

	{

	// Just for Unicode, need to "widen" the label!

	TBuf<63> label;

	label.Copy(iLabel);

	aControl.ShowTextf(_L("Node: Level = %d, Label = %S"), iLevel, &label);

	iRecordList.Print(aControl);

	iChildren.Print(aControl);

	}

#endif

// TDndNodeList.:TDndNodeList

// **************************

TDndNodeList::TDndNodeList() : TDblQue<CDndNode>(CDndNode::iOffset) 

	{}

// TDndNodeList::Find

// ******************

CDndNode * TDndNodeList::Find(const TNodeLabel &aLabel)

	{

	CDndNode *node;

	TDblQueIter<CDndNode> iter(*this);

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

		if (DnsCompareNames(node->iLabel, aLabel))

			return node;

	return NULL;

	}

// TDndNodeList::AddNode

// *********************

void TDndNodeList::AddNode(CDndNode &aNode)

	{

	AddFirst(aNode);

	}

// TDndNodeList::DeleteNode

// ************************

void TDndNodeList::DeleteNode(CDndNode *const aNode)

	{

	aNode->iDlink.Deque();

	delete aNode;

	}

#ifdef _LOG

// TDndNodeList::Print

// *******************

void TDndNodeList::Print(CDndEngine &aControl)

	{

	aControl.ShowText(_L("Node list: "));

	if (IsEmpty())

		aControl.ShowText(_L(" - No nodes"));

	else

		{

		CDndNode *node;

		TDblQueIter<CDndNode> iter(*this);

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

			node->Print(aControl);

		}

	}

#endif