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

// llmnrresponder.cpp - DND Link-local Multicast Name Resolution 

// responder module 

//

#ifdef LLMNR_ENABLED

#include <e32math.h>

#include <in_iface.h>

#include <in6_if.h>

#include "engine.h"

#include "llmnrresponder.h"

#include "llmnrconflict.h"

#include <networking/dnd_err.h>

#include "serverconf.h"

#include "inet6log.h"

enum TEntryState

	{

	EInactive = 0,	//< Entry is not yet available

	EUnique = 1,	//< Entry is unique and alive

	EDisabled = -1,	//< Entry is faulty, disabled

	EConflict = -2	//< Entry has conflict with another host

	};

class CNotifyConflict : public CActive

	/**

	Exists while a conflict notifier process is active.

	*/

	{

private:

	CNotifyConflict(CDndLlmnrResponder &aResponder, CLlmnrEntry &aEntry);

	void DoStart();

public:

	~CNotifyConflict();

	static void Start(CDndLlmnrResponder &aResponder, CLlmnrEntry &aEntry);

	void DoCancel();

	void RunL();

	CDndLlmnrResponder &iResponder;

	CLlmnrEntry &iEntry;

	TPckgBuf<TLlmnrConflictNotify> iInfo;

	RNotifier iNotifier;

	TUint iConnected:1;

	};

class CLlmnrEntry : public CBase

	/**

	Describes an answer (RR) that can be asked from this node.

	An instance of this object is created for each unique answer

	which this node is responsible for at this point of time.

	Each entry describes an answer for a specific interface.

	If the same name is defined for multiple interfaces,

	then multiple instances are created

	(one for each interface).

	These entries are created and deleted dynamically, as

	interfaces go up and down.

	*/

	{

public:

	~CLlmnrEntry();

	CLlmnrEntry *iNext;				//< Links the entry set together (head is CDndLlmnrResponder::iEntryList)

	TDndQuestion iQuestion;			//< The question that is answered by this entry

	TInetScopeIds iZone;			//< The scope vector of the related interface.

	TIpVer iVersion:8;				//< Which protocol: IPv4 or IPv6

	TEntryState iState:8;			//< State of this entry.

	TUint iDown:1;					//< Used in interface tracking

	TUint iHostName:1;				//< Set 1, if the name depends on the local hostname.

	CNotifyConflict *iNotify;		//< Non-NULL when conlict nofitication is in progress

	};

// TRawAddr

// *********

// Lightweight internal help class for handling the link layer addresses

// (modified from ipadm engine.cpp)

class TRawAddr : public TSockAddr

	{

public:

	TInt Append(TDes8& aBuf) const

		{

		TUint8* p = (TUint8*)UserPtr();

		TInt len = ((TSockAddr *)this)->GetUserLen();

		if (len == 0)

			return KErrNotSupported;

		if (aBuf.MaxLength() < aBuf.Length() + len * 2)

			return KErrNoMemory;

		while (--len >= 0)

			aBuf.AppendFormat(_L8("%02X"), *p++ & 0xFF);

		return KErrNone;

		}

	inline static TRawAddr& Cast(const TSockAddr& aAddr)

		{

		return *((TRawAddr *)&aAddr);

		}

	};

CLlmnrEntry::~CLlmnrEntry()

	{

	delete iNotify;

	}

CDndLlmnrResponder::CDndLlmnrResponder(CDndEngine &aControl,

									   MDnsServerManager &aServerManager,

									   THostNames &aHostNames)

	: iControl(aControl),

	  iServerManager(aServerManager),

	  iHostNames(aHostNames)

	{

	// Need to initialize the request blocks with "parent" pointer

	for (TUint i = 0; i < sizeof(iLlmnrDataList) / sizeof(iLlmnrDataList[0]); ++i)

		iLlmnrDataList[i].iParent = this;

	}

CDndLlmnrResponder::~CDndLlmnrResponder()

	{

	// Make sure all requests are totally idle

	for (TUint i = 0; i < sizeof(iLlmnrDataList) / sizeof(iLlmnrDataList[0]); ++i)

		{

		iLlmnrDataList[i].iTimeout.Cancel();

		iLlmnrDataList[i].Cancel();

		}

	while (iEntryList)

		{

		CLlmnrEntry *p = iEntryList;

		iEntryList = p->iNext;

		delete p;

		}

	delete iLlmnrNotifyHandler;

	delete iLlmnrConf;

	}

void CDndLlmnrResponder::ConstructL()

	{

	LOG(Log::Printf(_L("CDndLlmnrResponder::ConstructL() size=%d\r\n"), (TInt)sizeof(*this)));

	CDnsSocket::ConstructL ();

	iLlmnrConf = new (ELeave) CLlmnrConf(iControl);

	iLlmnrConf->ConstructL();

	iLlmnrConf->GetHostNamesL();

	iLlmnrNotifyHandler = new (ELeave) CDndLlmnrNotifyHandler(*this);

	iLlmnrNotifyHandler->ConstructL();

	}

void CDndLlmnrResponder::ConfigurationChanged()

	{

	iLlmnrNotifyHandler->ConfigurationChanged();

	}

void CDndLlmnrResponder::ActivateSocketL()

	{

	if (iConnected && IsOpened())

		return;			// Assume all done

	const TDndConfigParameters &cf = iControl.GetConfig();

	const TInetAddr bind(TInetAddr(cf.iLlmnrPort));

	CDnsSocket::ActivateSocketL(bind);

	// Disable multicast loopback to lessen the possibility to receive our own replies

	(void)Socket().SetOpt(KSoIp6MulticastLoop, KSolInetIp, 0);

	// Set Unicast and Multicast TTL/Hop limit to 1 for LLMNR responses

	(void)Socket().SetOpt(KSoIp6UnicastHops, KSolInetIp, cf.iLlmnrHoplimit);

	(void)Socket().SetOpt(KSoIp6MulticastHops, KSolInetIp, cf.iLlmnrHoplimit);

	(void)Socket().SetOpt(KSoUserSocket, KSolInetIp, 0);

	// THe LLMNR responder socket does not need to keep the interfaces up.

	(void)Socket().SetOpt(KSoKeepInterfaceUp, KSolInetIp, 0);

	ActivateListenL(bind, 1);

	}

// Join multicast group to LLMNR responder iSocket

TInt CDndLlmnrResponder::JoinMulticastGroup(TUint32 aIndex, TIpVer aIpVer)

	{

	TPckgBuf<TIp6Mreq> opt;

	TRAPD(err, ActivateSocketL());	// Need socket opened...

	if (err != KErrNone)

		return err;

	if(aIpVer == EIPv4)

		opt().iAddr = iControl.GetConfig().iLlmnrIpv4;

	else

		opt().iAddr = iControl.GetConfig().iLlmnrIpv6;

	opt().iInterface = aIndex;

	err=Socket().SetOpt(KSoIp6JoinGroup, KSolInetIp, opt);

	if ((err != KErrNone)&&(err != KErrInUse)) // may return KErrInUse when multicast hook is on

		{

		LOG(Log::Printf(_L("CDndLlmnrResponder::JoinMulticastGroup SetOpt KSoIp6JoinGroup if=%d error: %d"), aIndex, err));

		return err;

		}

	return KErrNone;

	}

TInt CDndLlmnrResponder::MakeMyAddr(const TUint32 aIfIndex, const TInetAddr &aTarget, EDnsType aType, TInetAddr &aAddr)

	{

	const EDnsType target_type = (aTarget.Family() == KAfInet || aTarget.IsV4Mapped()) ? EDnsType_A : EDnsType_AAAA;

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iIndex = aIfIndex;

	for (;;)

		{

		TInt err;

		if (aType == target_type)

			{

			// The target address matches the address type being queried,

			// try obtaining the "best address" that matches the target.

			opt().iDstAddr = aTarget;

			if ((err = iControl.iSocket.GetOpt(KSoInetIfQueryByIndex, KSolInetIfQuery, opt)) != KErrNone)

				return err;

			if (!opt().iSrcAddr.IsUnspecified())

				break;	// Success!

			}

		// Try finding an acceptable link local or any higher scope address

		if (aType == EDnsType_A)

			opt().iDstAddr.SetV4MappedAddress(KInetAddrLinkLocalNet); 

		else if (aType == EDnsType_AAAA)

			opt().iDstAddr.SetAddress(KInet6AddrLinkLocal);

		else

			return KErrNotSupported;

		if ((err = iControl.iSocket.GetOpt(KSoInetIfQueryByIndex, KSolInetIfQuery, opt)) != KErrNone)

			{

			LOG(Log::Printf(_L("CDndLlmnrResponder::MakeMyAddr GetOpt KSoInetIfQueryByIndex error: %d"),err));

			return err;

			}

		break;

		// *NEVER GET HERE!*

		}

	//

	// Address is unspecified or some valid source address

	//

	aAddr = opt().iSrcAddr;

	return KErrNone;

	}

#ifdef _LOG

void CDndLlmnrResponder::LogPrint(const TDesC &aStr, const CLlmnrEntry &aEntry)

	{

	TBuf<KDnsMaxName> name;

	aEntry.iQuestion.GetName(name);

	Log::Printf(_L("%S%S QType=%d State=%d ip%d for if=%u\r\n"),

		&aStr,

		&name, (TInt)aEntry.iQuestion.QType(),

		(TInt)aEntry.iState,

		(TInt)aEntry.iVersion,

		(TInt)aEntry.iZone[0]);

	}

void CDndLlmnrResponder::LogPrint(const TDesC &aStr, const TDndQuestion &aQuestion)

	{

	TBuf<KDnsMaxName> name;

	aQuestion.GetName(name);

	Log::Printf(_L("%S%S QType=%d\r\n"),

		&aStr,

		&name, (TInt)aQuestion.QType());

	}

#endif

// Mark all entries as "unupdated"

void CDndLlmnrResponder::UpdateStart()

	{

	for(CLlmnrEntry *entry = iEntryList; entry != NULL; entry = entry->iNext)

		entry->iDown = 1;

	}

// Remove all entries that were not updated (interface has gone down)

void CDndLlmnrResponder::UpdateFinish()

	{

	for(CLlmnrEntry **h = &iEntryList;;)

		{

		CLlmnrEntry *entry = *h;

		if (entry == NULL)

			break;	// -- all done!

		if (entry->iDown ||

			JoinMulticastGroup(entry->iZone[0], STATIC_CAST(TIpVer, entry->iVersion)) != KErrNone)

			{

			//

			// Remove entry. Either interface is down (not exist) or

			// it does not support multicast, in which case it cannot

			// be used for LLMNR.

			//

			*h = entry->iNext;

			//

			// If entry has any associated requests outstanding,

			// they must be cancelled.

			CancelAll(*entry);

			LOG(LogPrint(_L("\tLLMNR removed: "), *entry));

			delete entry;

			}

		else

			{

			//

			// Entry is still active and usable

			//

			h = &entry->iNext;

			continue;

			}

		}

	if (iEntryList == NULL)

		{

		// Nothing enabled for LLMNR, no need to keep the socket either

		DeactivateSocket();

		LOG(Log::Printf(_L("CDndLlmnrResponder::UpdateFinish - no entries, socket deactivated\r\n")));

		}

	}

TInt CDndLlmnrResponder::UpdateInterface

	(const TName &aIfName, const TIpVer aIpVer, const TInetScopeIds &aZone, const TSockAddr &aHwAddr, TInt aLlmnrDisable)

	/**

	* Update the LLMNR entries for the specified interface.

	*

	* @param aIfName	The interface name

	* @parma aIpVer		The IP version (either EIPv4 or EIPv6)

	* @param aZone		The zone ids

	* @param aHwAddr	The hardware address (if present)

	* @param aLlmnrDisable	=1, if LLMNR is to be disabled on this interface

	*/

	{

	// Check that this is not a loopback interface

	if(!aZone[1])

		return KErrNone;

	// An interface is open. Check if it is LLMNR enabled and if update(s)

	// have not been sent or disabled

	TInt is_active = 0;

	for(CLlmnrEntry *entry = iEntryList; entry != NULL; entry = entry->iNext)

		{

		if (entry->iZone[0] == aZone[0])

			{

			is_active = 1;

			// If LLMNR is to be disable, this keeps iDown as 1 and

			// the entry will be deleted in UpdateFinish.

			entry->iDown = aLlmnrDisable;

			//

			// Copy the scope vector each time, in case it has been modified

			//

			for (TUint k = 0; k < sizeof(TInetScopeIds) / sizeof(entry->iZone[0]); k++)

				entry->iZone[k] = aZone[k];

			}

		}

	if (is_active || aLlmnrDisable)

		return KErrNone;	// Interface already activated or being disabled, nothing else to do.

	// Interface is not yet LLMNR enabled, Check if there

	// are hostnames enabled that match this interface

	const EDnsQType qt = aIpVer == EIPv4 ? EDnsQType_A : aIpVer == EIPv6 ? EDnsQType_AAAA : EDnsQType(0);

	const TInt N = iLlmnrConf->iHostList->Count();

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

		{

		const THostNameEntry &host = iLlmnrConf->iHostList->At(i);

		if (host.iVersion != EIPany && host.iVersion != aIpVer)

			continue;	// Does not apply to this entry, go look next

		if (host.iIfName.Length() > 0 && host.iIfName.Compare(aIfName) != 0)

			continue;	// Entry is for a specific interface (not this), go look next

		//

		// Build a new LLMNR entry

		//

		TInetAddr addr(iControl.GetConfig().iLlmnrPort);

		// Give name and address to the server manager

		if(aIpVer == EIPv4)

			addr.SetAddress(iControl.GetConfig().iLlmnrIpv4);

		else

			addr.SetAddress(iControl.GetConfig().iLlmnrIpv6);

		iServerManager.AddServerAddress(aIfName, addr);

		// Make an entry to the list

		CLlmnrEntry *entry = new CLlmnrEntry();

		if (entry == NULL)

			break;	// Ooops, out of memory...

		entry->iNext = iEntryList;

		iEntryList = entry;

		entry->iQuestion.SetName(host.iName);

		entry->iQuestion.SetQType(qt);

		entry->iQuestion.SetQClass(EDnsQClass_IN);

		entry->iVersion = aIpVer;

		//

		// Copy the scope vector

		//

		for (TUint k = 0; k < sizeof(TInetScopeIds) / sizeof(entry->iZone[0]); k++)

			entry->iZone[k] = aZone[k];

		entry->iState = EInactive;

		if(FormatHostName(*entry, aHwAddr) == KErrNone)

			(void)DoUpdate(*entry);

		else

			entry->iState = EDisabled;

		LOG(LogPrint(_L("\tLLMNR Created: "), *entry));

		}

	return KErrNone;

	}

TInt CDndLlmnrResponder::FormatHostName(CLlmnrEntry &aEntry, const TSockAddr &aHwAddr)

	{

	TInt i;

	aEntry.iHostName = 0;

	if((i = aEntry.iQuestion.Find(FORMATHWADDR)) != KErrNotFound)

		{ // hostname contains hardware address format string

		if(aHwAddr.Family() == KAFUnspec)

			{

			LOG(Log::Printf(_L("CDndLlmnrResponder::FormatHostName - no hw address\r\n")));

			return  KErrNotFound;

			};

		// Insert hw address into hostname

		// (We assume, that there is only one hw address insert in the hostname)

		TDndName tmpstr;

		tmpstr.Append(aEntry.iQuestion.Left(i));

		TInt err;

		if((err = TRawAddr::Cast(aHwAddr).Append(tmpstr)) != KErrNone)

			return err;

		tmpstr.Append(aEntry.iQuestion.Mid(i + FORMATHWADDR().Length()));

		(TDndName &)aEntry.iQuestion = tmpstr;

		return KErrNone;

		}

	else if((i = aEntry.iQuestion.Compare(WILDCARDPRIMARYHOSTNAME)) == 0)

		{

		// Entry requests use of local hostname. Find a matching local name

		// based on the network id.

		aEntry.iHostName = 1;

		const TUint32 nid = aEntry.iZone[KIp6AddrScopeNetwork-1];

		(void)iHostNames.Refresh(nid);	// Reread hostname from Comms Database.

		aEntry.iQuestion.SetName(iHostNames.Find(nid));

		return aEntry.iQuestion.Length() > 0 ? KErrNone : KErrNotFound;

		}

	else

		return KErrNone; // No format string in hostname

	}

void CDndLlmnrResponder::CancelAll(const CLlmnrEntry &aEntry)

	{

	// Abort all associated requests, if any

	for (TInt session = 0; session < KLlmnrMaxSessions; ++session)

		if(iLlmnrDataList[session].iLlmnrEntry == &aEntry)

			{

			iLlmnrDataList[session].iTimeout.Cancel();

			iLlmnrDataList[session].Cancel();

			iLlmnrDataList[session].iLlmnrEntry = NULL;

			}

	}

TInt CDndLlmnrResponder::DoUpdate(CLlmnrEntry &aEntry)

	{

	if (JoinMulticastGroup(aEntry.iZone[0], STATIC_CAST(TIpVer, aEntry.iVersion)) != KErrNone)

		{

		// The interface does not support multicast, disable entry.

		LOG(LogPrint(_L("CDndLlmnrResponder::DoUpdate() No multicast, disable: "), aEntry));

		aEntry.iState = EDisabled;

		return KErrNotSupported;

		}

	TInt session = 0;

	for(session=0; ; session++)

		{

		if(session == KLlmnrMaxSessions)

			{

			LOG(Log::Printf(_L("CDndLlmnrResponder::DoUpdate - No free slots in iLlmnrDataList")));

			return KErrNoMemory;

			}

		if(!iLlmnrDataList[session].iLlmnrEntry)

			break;

		}

	TLlmnrMsgData &upd = iLlmnrDataList[session];

	upd.iLlmnrEntry = &aEntry;

	// Do Unique check by sending a query for the name, and if nobody answers within

	// specified time, assume the name is valid to use for this node.

	upd.iQuestion = aEntry.iQuestion;

	upd.iQR = 0;

	upd.iAA = 0;

	upd.iRCode = EDnsRcode_NOERROR;

	if (aEntry.iVersion == EIPv4)

		upd.iDstAddr.SetAddress(iControl.GetConfig().iLlmnrIpv4);

	else

		upd.iDstAddr.SetAddress(iControl.GetConfig().iLlmnrIpv6);

	upd.iDstAddr.SetScope(aEntry.iZone[upd.iDstAddr.Ip6Address().Scope()-1]);

	upd.iDstAddr.SetPort(iControl.GetConfig().iLlmnrPort);

	upd.iRepeat = 1 + iControl.GetConfig().iLlmnrRetries;

	Queue(upd);

	return KErrNone;