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

// servers.cpp - server manager module

//

#include "servers.h"

#include "engine.h"

#include "inet6log.h"

#include "dns_hdr.h"	// only for KDnsPort!

#include "dnd.hrh"

// Item of the server list, hold DNS server information

class TDnsServerData

	{

public:

	TInetAddr iAddr;			//< DNS Server Address

	TDnsServerScope iScope;		//< The Sever Scope and type (MC/UC)

	TInt iServerId;				//< Id of the server

	TInt iInterface;			//< Index to Interface Array

	};

// Item of the interface list, hold interface information for DNS

class TDnsInterfaceData

	{

public:

	TName iName;				//< Name of the interface

	TUint32 iScope[16];			//< The scope vector

	};

// Item of the configured servers list

class TDnsConfiguredServer

	{

public:

	TName iName;

	TInetAddr iAddr;

	};

class CDnsServerManager : public CBase, public MDnsServerManager

	{

	~CDnsServerManager();

public:

	CDnsServerManager(CDndEngine &aControl);

	void ConstructL();

	void ConfigurationChanged();

	//

	// MDnsServerManager API

	// (for docs, see the MDnsServerManger definitions)

	//

	TInt OpenList(const TDnsServerFilter &aFilter, MDnsServerListNotify *aNotify);

	TInt Count(const TDnsServerFilter &aFilter) const;

	TInt Next(const TDnsServerFilter &aFilter, TInt aServerId) const;

	void CloseList(const TDnsServerFilter &aFilter);

	TInt Address(TInt aServerId, TInetAddr &aAddr) const;

	TUint32 Scope(TInt aServerId, const TInetAddr &aAddr);

	TInt ServerId(const TInetAddr &aAddr) const;

	TUint32 NameSpace(const TDnsServerFilter &aFilter, TInt aServerId) const;

	TInt BuildServerList();

	void AddServerAddress(const TName &aInterface, const TInetAddr &aAddr);

	void LockByAddress(const TInetAddr &aAddr, TUint32 aNid, TDnsServerFilter &aFilter);

private:

	// Build and add interface entry to the list (basic operation)

	TInt AddInterfaceEntry(const TSoInetIfQuery &aInfo);

	// Find interface matching the destination address

	TInt FindInterface(const TInetAddr &aAddr);

	// Add new server address to the server list

	void AddToServerList(const TInetAddr &aAddr, TInt aIf, RSocket &aSocket);

	// Add new interface to the interface list

	TInt AddToInterfaceList(const TSoInetInterfaceInfo &aInfo, RSocket &aSocket);

	// Compare the filter with a DNS server

	TBool Match(const TDnsServerFilter &aFilter, const TDnsServerData &aServer) const;

	CDndEngine &iControl;

	TUint32 iServerId;				//< The last used server id.

	TTime iMark;					//< The time of the last configuration change.

	TUint iConfigure:1;				//< Reconfigure needed, if set.

	TUint iStable:1;				//< = 1, when scanned list is supposed to be stable

	TUint iCacheFlushed:1;			//< = 1, when cache has been flushed (only used with "FlushOnConfig" ini-option)

	CArrayFixFlat<TDnsServerData> *iServerList;	//< Current list of servers

	CArrayFixFlat<TDnsInterfaceData> *iInterfaceList; //< Current list of interfaces

	CArrayFixFlat<TDnsConfiguredServer> *iConfiguredList; //< Current list of configured servers

	};

MDnsServerManager *DnsServerManager::NewL(CDndEngine &aControl)

	{

	CDnsServerManager *mgr = new (ELeave) CDnsServerManager(aControl);

	CleanupStack::PushL(mgr);

	mgr->ConstructL();

	CleanupStack::Pop();

	return mgr;

	}

//

// CDnsServerManager

//

CDnsServerManager::CDnsServerManager(CDndEngine &aControl) : iControl(aControl)

	{

	}

void CDnsServerManager::ConstructL()

	{

	iServerList = new (ELeave) CArrayFixFlat<TDnsServerData>(2);

	iInterfaceList = new (ELeave) CArrayFixFlat<TDnsInterfaceData>(5);

	// iConfiguredList is allocated only if required.

	}

void CDnsServerManager::ConfigurationChanged()

	{

	LOG(Log::Printf(_L("CDnsServerManager -- Configuration changed")));

	// Just flag that building a new server list is needed. Try

	// to delay heavy interface scanning operation until really

	// needed (because configuration changes may come in burts).

	iConfigure = 1;

	iStable = 0;

	iCacheFlushed = 0;

	iMark.UniversalTime();

	}

CDnsServerManager::~CDnsServerManager()

	{

	delete iServerList;

	delete iInterfaceList;

	delete iConfiguredList;

	}

// CDnsServerManager::AddInterfaceData

TInt CDnsServerManager::AddInterfaceEntry(const TSoInetIfQuery &aInfo)

	{

	TRAPD(err,

		TDnsInterfaceData &ifd = iInterfaceList->ExtendL();

		ifd.iName = aInfo.iName;

		for (TInt i = sizeof(ifd.iScope) / sizeof(ifd.iScope[0]); --i >= 0; )

			ifd.iScope[i] = aInfo.iZone[i];

		);

	return err < 0 ? err : iInterfaceList->Count() - 1;

	}

// CDnsServerManager::AddToInterfaceList

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

/**

// Add the interface to the interface list, if it does not already exist.

// The existence is based on comparing the interface names.

//

// @param	aInfo	the information that identifies the interface

// @param	aSocket	(must be open) to be used for GetOpt, if needed

// @returns

//	@li	< 0, if there are some errors (interface was not added)

//	@li index to the interface (>= 0) in the interface list.

*/

TInt CDnsServerManager::AddToInterfaceList(const TSoInetInterfaceInfo &aInfo, RSocket &aSocket)

	{

	if (aInfo.iName.Length() == 0)

		return -1;	// Interface must have a name.

	//

	// Check if interface already exists and don't insert duplicates

	//

	TInt i;

	for (i = iInterfaceList->Count(); --i >= 0; )

		{

		const TDnsInterfaceData &data = iInterfaceList->At(i);

		if (data.iName.Compare(aInfo.iName) == 0)

			return i;	// Interface already present in the list

		}

	//

	// A new interface, get the scope vector

	//

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iName = aInfo.iName;

	const TInt err = aSocket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, opt);

	return err < 0 ? err : AddInterfaceEntry(opt());

	}

// CDnsServerManager::FindInterface

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

//

TInt CDnsServerManager::FindInterface(const TInetAddr &aAddr)

	{

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iDstAddr = aAddr;

	const TInt err = iControl.iSocket.GetOpt(KSoInetIfQueryByDstAddr, KSolInetIfQuery, opt);

	if (err < 0)

		return err;

	// Check if interface is already known

	for (TInt i = iInterfaceList->Count(); --i >= 0; )

		{

		const TDnsInterfaceData &data = iInterfaceList->At(i);

		if (data.iName.Compare(opt().iName) == 0)

			return i;

		}

	// Not present yet, just add it

	return AddInterfaceEntry(opt());

	}

// CDnsServerManager::AddToServerList

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

/**

// Add new address to the server list. A new entry is only

// added if the address does not already exist.

//

// @param	aAddr	address of the DNS server

// @param	aIf		the interface (index to the interface list)

*/

void CDnsServerManager::AddToServerList(const TInetAddr &aAddr, TInt aIf, RSocket &aSocket)

	{

	if (aAddr.IsUnspecified())

		return;		// No address, nothing to add

	//

	// Normalize all addresses into IPv6 format

	//

	TDnsServerData sd;

	sd.iAddr = aAddr;

	sd.iInterface = aIf;

	if (sd.iAddr.Family() == KAfInet)

		sd.iAddr.ConvertToV4Mapped();

	else if (sd.iAddr.Family() != KAfInet6)

		return;		// Only IPv4 or IPv6 addresses are valid

	if (sd.iAddr.IsMulticast())

		//	sd.iScope = (TDnsServerScope)(sd.iAddr.Ip6Address().Scope());

		sd.iScope = EDnsServerScope_MC_LOCAL;

	else

		sd.iScope = EDnsServerScope_UC_GLOBAL;

	if (!sd.iAddr.Port())

		sd.iAddr.SetPort(KDnsPort);

	LOG(TBuf<80> dst);

	LOG(sd.iAddr.OutputWithScope(dst));

	LOG(TBuf<80> src);

	// In typhoon and later, DND never activates interfaces. All

	// usable server addresses must have a valid route, before

	// they can be used. Thus, check it...

	//

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iDstAddr = aAddr;

	const TBool has_route =

		(aSocket.GetOpt(KSoInetIfQueryByDstAddr, KSolInetIfQuery, opt) == KErrNone) && !opt().iSrcAddr.IsUnspecified();

	LOG(opt().iSrcAddr.OutputWithScope(src));

	if (!has_route)

		{

		LOG(Log::Printf(_L("\t\tnameserver [%S] (src=%S) has no route or no source address, skipped"), &dst, &src));

		return;				// No route, unusable for now -- ignore

		}

	//

	// Check if address already exists and don't insert duplicates

	//

	for (TInt i = iServerList->Count(); --i >= 0; )

		{

		TDnsServerData &a = iServerList->At(i);

		if (a.iAddr.Match(sd.iAddr) && a.iAddr.Scope() == sd.iAddr.Scope())

			{

			// However, if server didn't have assigned

			// interface yet, assign it from this call.

			//

			if (a.iInterface < 0)

				a.iInterface = aIf;

			LOG(Log::Printf(_L("\t\tnameserver (id=%d) [%S] (src=%S)"), a.iServerId, &dst, &src));

			return;	// Duplicate address, do not add again.

			}

		}

	sd.iServerId = ++iServerId;	// Assign a "server id"

	LOG(Log::Printf(_L("\t\tnameserver (id=%d) [%S] (src=%S) (new)"), sd.iServerId, &dst, &src));

	TRAP_IGNORE(iServerList->AppendL(sd));

	}

// CDnsServerManager::BuildServerList

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

TInt CDnsServerManager::BuildServerList()

	{

	LOG(Log::Printf(_L("CDnsServerManager -- Scanning interfaces and building the server list")));

	TInt err = KErrNone;

	// Refresh the current list of DNS server addresses

	// (this could be skipped if there was some definite way of knowing

	// that nothing has changed since the last collect...)

	// Use Delete instead of Reset, so that space is reused? (not freed and reallocated)

	iInterfaceList->Delete(0, iInterfaceList->Count());

	// Trying to keep "server id" stable, thus do not clear existing

	// server list, but just mark entries, so that unused ones can be 

	// reclaimed after build is complete.

	for (TInt i = iServerList->Count(); --i >= 0; )

		iServerList->At(i).iInterface = -2;

	LOG(Log::Printf(_L("\t* Scanning interfaces")));

	// Read the DNS address from the interface

	TSoInetInterfaceInfo *info = new TSoInetInterfaceInfo; // allocate large struct from heap!

	if (info && (err = iControl.iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl)) == KErrNone)

		{

		TPckg<TSoInetInterfaceInfo> opt(*info);

		while (iControl.iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt) == KErrNone)

			{

			if (opt().iName.Length() == 0)

				continue;	// "null" interface, ignore

			if (!opt().iAddress.IsUnspecified())

				{

#ifdef _LOG

				TBuf<60> tmp;

				opt().iAddress.OutputWithScope(tmp);

				Log::Printf(_L("\t%S [%S]"), &opt().iName, &tmp);

#endif

				TInt i = AddToInterfaceList(opt(), iControl.iSocket);

				AddToServerList((TInetAddr &)(opt().iNameSer1), i, iControl.iSocket);

				AddToServerList((TInetAddr &)(opt().iNameSer2), i, iControl.iSocket);

				}

			else

				{

				LOG(Log::Printf(_L("\tInterface: %S [no address, skipping]"), &opt().iName));

				}

			}

		}

	delete info;

	LOG(Log::Printf(_L("\t* Configured interface specific addresses")));

	//

	// Add configured servers, if a matching interface has become available

	// (assumes that configured list and interface list are always short, so

	// the loop over all lists is not too bad...)

	if (iConfiguredList)

		{

		for (TInt i = iConfiguredList->Count(); --i >= 0; )

			{

			const TDnsConfiguredServer &cs = iConfiguredList->At(i);

			for (TInt j = iInterfaceList->Count(); --j >= 0; )

				{

				const TDnsInterfaceData &data = iInterfaceList->At(j);

				if (data.iName.Compare(cs.iName) == 0)

					{

					// Complete the address with the scope id

					// from the interface!

					TInetAddr addr(cs.iAddr);

					if (addr.Family() == KAfInet)

						addr.ConvertToV4Mapped();

					const TUint s = addr.Ip6Address().Scope() - 1;

					if (s < 16)

						{

						addr.SetScope(data.iScope[s]);

						AddToServerList(addr, j, iControl.iSocket);

						}

					break;

					}

				}

			}

		}

	//

	// Remove unused servers from the list

	//

	LOG(Log::Printf(_L("\t* Remove stale addresses")));

	const TInt N = iServerList->Count();

	TInt k = 0;

	for (TInt j = 0; j < N; ++j)

		{

		const TDnsServerData &a = iServerList->At(j);

		if (a.iInterface != -2)

			{

			// This server entry is still used

			if (k != j)

				iServerList->At(k) = a;

			k++;

			}

#ifdef _LOG

		else

			{

			TBuf<80> tmp;

			a.iAddr.OutputWithScope(tmp);

			Log::Printf(_L("\t\tnameserver (id=%d) [%S] deleted"), a.iServerId, &tmp);

			}

#endif

		}

	if (k < N)

		{

		iServerList->Delete(k, N - k);

		}

	LOG(Log::Printf(_L("CDnsServerManager -- Done, current server count=%d"), iServerList->Count()));

	return err;

	}

// CDnsServerManager::AddServerAddress

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

void CDnsServerManager::AddServerAddress(const TName &aInterface, const TInetAddr &aAddr)

	{

	if (iConfiguredList == NULL &&

		(iConfiguredList = new CArrayFixFlat<TDnsConfiguredServer>(5)) == NULL)

		return;		// No memory for the allocation, ignore..

	// Do not add duplicates, check existing entries

	for (TInt i = iConfiguredList->Count(); --i >= 0; )

		{

		const TDnsConfiguredServer &cs = iConfiguredList->At(i);

		if (cs.iName.Compare(aInterface) == 0 && cs.iAddr.Match(aAddr))

			return;	// Duplicate!

		}

	iConfigure = 1;	// Request rebuild of server list.

	TRAP_IGNORE(TDnsConfiguredServer &cf = iConfiguredList->ExtendL();

		cf.iAddr = aAddr;

		cf.iName = aInterface;

		);

	}

/**

// @param	aFilter	the server filter

// @parma	aServer	to be tested against the filter

// @returns

//	@li	TRUE, if the server matches the filter

//	@li	FALSE, if the server does not match the filter

*/

TBool CDnsServerManager::Match(const TDnsServerFilter &aFilter, const TDnsServerData &aServer) const

	{

	if (aFilter.iServerScope != aServer.iScope)

		return FALSE;

	if (aFilter.iLockType < KIp6AddrScopeNodeLocal || aFilter.iLockType > KIp6AddrScopeNetwork)

		return FALSE;	// actually invalid locking scope level

	// If a server address is specified without interface (-1), then this

	// server will match any filter (if server scopes are same).

	if (aServer.iInterface >= 0)

		{

		const TDnsInterfaceData &id = iInterfaceList->At(aServer.iInterface);

		if (aFilter.iLockId != id.iScope[aFilter.iLockType-1])

			return FALSE;	// Not in locked scope

		}

	return 	TRUE;

	}

//

// MDnsServerManager API

//

TInt CDnsServerManager::OpenList(const TDnsServerFilter &aFilter, MDnsServerListNotify * /*aNotify*/)

	{

	if (iConfigure)

		{

		const TInt err = BuildServerList();

		if (err != KErrNone)

			return err;

		iConfigure = 0;

		}

	if (iStable)

		return KErrNone;

	if (iControl.GetConfig().iFlushOnConfig && iCacheFlushed == 0)

		{

		iCacheFlushed = 1;

		TRAP_IGNORE(iControl.HandleCommandL(EDndFlush));

		}

	TTime stamp;

	stamp.UniversalTime();

	TTimeIntervalSeconds elapsed;

	stamp.SecondsFrom(iMark, elapsed);

	if (elapsed.Int() > (TInt)iControl.GetConfig().iSetupTime)

		{

		iStable = 1;

		return KErrNone;

		}

	if (aFilter.iServerScope == EDnsServerScope_MC_LOCAL)

		return KErrNone;		

	// We are still within setup time, return "pending" if no servers available

	return (Count(aFilter) == 0) ? 1 : KErrNone;

	}

TInt CDnsServerManager::Count(const TDnsServerFilter &aFilter) const

	{

	TInt count = 0;

	for (TInt i = iServerList->Count(); --i >= 0; )

		if (Match(aFilter, iServerList->At(i)))

			++count;

	return count;

	}

TInt CDnsServerManager::Next(const TDnsServerFilter &aFilter, TInt aServerId) const

	{

	const TInt N = iServerList->Count();

	TInt wrap = 0;

	TInt first_found = 0;

	TInt current_found = 0;

	if (aServerId == 0)

		{

		//

		// When "current" server is not specified, Next will

		// return the first server (specified by iServerId)

		//

		for (TInt i = 0; i < N; ++i)

			{

			const TDnsServerData &server = iServerList->At(i);

			if (server.iServerId == aFilter.iServerId)

				first_found = 1;

			if (first_found)

				{

				if (Match(aFilter, server))

					return server.iServerId;

				}

			else if (wrap == 0 && Match(aFilter, server))

				wrap = server.iServerId;

			}

		//

		// iServerId server is not present (or it and none

		// of the servers after it do not match). Return

		// the first matching server.

		return wrap;

		}

	else

		{