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

// dns.cpp - the main client module of the DNS.

//

#include <e32math.h>

#include <in_sock.h>

#include <in6_opt.h>

#include "dns.h"

#include "dnd.hrh"		// EDndDump

#include <networking/dnd_err.h>

#include "engine.h"

#include "servers.h"

#include "cache.h"

#include "inet6log.h"

#ifdef LLMNR_ENABLED

#	include "llmnrresponder.h"

#endif

#include "dnd_ini.h"

#ifdef EXCLUDE_SYMBIAN_DNS_PUNYCODE

#undef SYMBIAN_DNS_PUNYCODE

#endif //EXCLUDE_SYMBIAN_DNS_PUNYCODE

class CDnsService : public CDndDnsclient

	{

public:

	CDnsService(CDndEngine &aControl, MDnsServerManager &aServerManager) : CDndDnsclient(aControl, aServerManager) {}

	void ConstructL();

	~CDnsService();

	virtual void ConfigurationChanged();

	TInt SetHostName(TUint32 aId, const THostName &aName);

	TInt GetHostName(TUint32 aId, THostName &aName, MDnsResolver &aCallback);

	TInt GetByAddress(TUint32 aId, const TInetAddr &aAddr, TInt aNext, THostName &aName);

	TInt GetByName(TUint32 aId, const THostName &aName, TInt aNext, TInetAddr &aAddr);

private:

#ifdef LLMNR_ENABLED

	CDndLlmnrResponder *iLlmnrResponder; //< Pointer to the LLMNR responder object

#endif

	TUint32 GetNetId(TUint32 aIndex);

	TInetAddressInfo *GetAddressList(TInt &aN);

	};

void CDnsService::ConstructL()

	{

	CDndDnsclient::ConstructL();

#ifdef LLMNR_ENABLED

	iLlmnrResponder = new (ELeave) CDndLlmnrResponder(iControl, iServerManager, iHostNames);

	iLlmnrResponder->ConstructL();

#endif

	}

CDnsService::~CDnsService()

	{

#ifdef LLMNR_ENABLED

	delete iLlmnrResponder;

#endif

	}

void CDnsService::ConfigurationChanged()

	{

#ifdef LLMNR_ENABLED

	iLlmnrResponder->ConfigurationChanged();

#endif

	}

//

// Gateway hostname processing to the responder

//

TInt CDnsService::SetHostName(TUint32 aId, const THostName &aName)

	{

	const TInt res = iHostNames.Map(aId, aName);

#ifdef LLMNR_ENABLED

	return res == KErrNone ? iLlmnrResponder->SetHostName(aId, iHostNames.Find(aId)) : res;

#else

	return res;

#endif

	}

TInt CDnsService::GetHostName(TUint32 aId, THostName &aName, MDnsResolver &aCallback)

	{

	aName = iHostNames.Find(aId);

#ifdef LLMNR_ENABLED

	return iLlmnrResponder->GetHostName(aId, aCallback);

#else

	(void)aCallback;

	return KErrNone;

#endif

	}

TUint32 CDnsService::GetNetId(TUint32 aIndex)

	{

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iIndex = aIndex;

	return iControl.iSocket.GetOpt(KSoInetIfQueryByIndex, KSolInetIfQuery, opt) == KErrNone

		? opt().iZone[15] : 0;

	}

TInetAddressInfo *CDnsService::GetAddressList(TInt &aN)

	/**

	* Returns a list of all current addresses.

	*

	* @retval aN	The number of addresses (if return is non-NULL).

	* @return		The address list, or NULL if not available.

	*

	* The returned address list must be freed by the caller

	* as "delete[] list".

	*/

	{

	TPtr8 empty(NULL, 0);

	aN = iControl.iSocket.GetOpt(KSoInetAddressInfo, KSolInetIfQuery, empty);

	if (aN <= 0)

		return NULL;

	TInetAddressInfo *p = new TInetAddressInfo[aN];

	if (p == NULL)

		return NULL;	// No memory available.

	TPtr8 opt((TUint8 *)p, aN*sizeof(TInetAddressInfo));

	aN = iControl.iSocket.GetOpt(KSoInetAddressInfo, KSolInetIfQuery, opt);

	if (aN < 0)

		aN = 0;

	else

		aN = opt.Length() / (TInt)sizeof(TInetAddressInfo);

	return p;

	}

TInt CDnsService::GetByAddress(TUint32 /*aId*/, const TInetAddr &aAddr, TInt /*aNext*/, THostName &aName)

	/**

	* Returns the local hostname, if address is my own.

	*/

	{

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iSrcAddr = aAddr;

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

		return KErrNotFound;

	aName = iHostNames.Find(opt().iZone[15]);	// Locate hostname for network id.

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

	}

TInt CDnsService::GetByName(TUint32 aId, const THostName &aName, TInt /*aNext*/, TInetAddr &aAddr)

	/**

	* Returns one of my own addresses, if the hostname is local.

	*/

	{

	const TDesC &name = iHostNames.Find(aId);

	if (aName.Length() > 0 && name.CompareF(aName) != 0)

		return KErrNotFound;	// The query name is not a local host.

	//

	// Locate a local addres from some interface within the specific network.

	//

	TInt N;

	TInetAddressInfo *list = GetAddressList(N);

	if (list == NULL)

		return KErrNotFound;

	TUint32 iface = 0;

	TUint32 netid = 0;

	TInt scope = -1;

	TInt best = 0;

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

		{

		if (list[i].iState != TInetAddressInfo::EAssigned)

			continue;

		if (list[i].iInterface != iface)

			{

				iface = list[i].iInterface;

				netid = GetNetId(iface);

			}

		if (netid != aId)

			continue;	// Not this address.

		if (list[i].iAddress.Scope() > scope)

			{

			scope = list[i].iAddress.Scope();

			best = i;

			}

		}

	aAddr.SetAddress(list[best].iAddress);

	aAddr.SetScope(list[best].iScopeId);

	delete[] list;

	return scope < 0 ? KErrNotFound : KErrNone;

	}

//

//

CDndDnsclient *CDndDnsclient::NewL(CDndEngine &aControl, MDnsServerManager &aServerManager)

	{

	LOG(Log::Printf(_L("CDndDnsclient::NewL()")));

	CDnsService *const dns = new (ELeave) CDnsService(aControl, aServerManager);

	CleanupStack::PushL(dns);

	dns->ConstructL();

	CleanupStack::Pop();

	return dns;

	}

CDndDnsclient::CDndDnsclient(CDndEngine &aControl, MDnsServerManager &aServerManager)

	: CDnsSocket(aControl.GetConfig().iEDNS0), iControl(aControl), iServerManager(aServerManager)

	{

	}

void CDndDnsclient::ConstructL()

	{

	LOG(Log::Printf(_L("CDndDnsclient::ConstructL() size=%d"), (TInt)sizeof(*this)));

	CDnsSocket::ConstructL();

	iCache = new (ELeave) CDndCache();

	iCache->ConstructL();

	TPtrC localhost;

	if(iControl.FindVar(DND_INI_HOST, DND_INI_HOSTNAME, localhost))

		(void)iHostNames.Reset(localhost);

	else

		(void)iHostNames.Reset(KDndIni_Hostname);

	}

void CDndDnsclient::HandleCommandL(TInt aCommand)

	{

#ifdef _LOG

	switch(aCommand)

		{

		case EDndDump:

			if (iCache)

				iCache->Dump(iControl);

			break;

		default:

			break;

		}

#endif

	if (aCommand == EDndFlush)

		iCache->Flush();

	}

CDndDnsclient::~CDndDnsclient()

	{

	DeactivateSocket();

	// Just to be sure, cancel server list notifys (if any)

	// (this means that SERVER MANAGER MUST NOT BE DELETED

	// before this object!)

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

		iServerManager.CloseList(iDndReqData[i].iFilter);

	delete iCache;

	}

// CDndDnsclient::CheckAddress

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

TInt CDndDnsclient::CheckAddress(const TInetAddr &aDestination)

	{

	TPckgBuf<TSoInetIfQuery> opt;

	opt().iDstAddr = aDestination;

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

	if (err == KErrNone && TInetAddr::Cast(opt().iSrcAddr).IsUnspecified())

		return KErrNotFound;	// No route or source address.

	return err;

	}

// TDndReqData::PickDefaultServer

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

TBool TDndReqData::PickDefaultServer()

	{

	TInetAddr tmp;

	TBool ret = FALSE;

	if (iCurrentServer == 0)

		ret = iOwner->iServerManager.OpenList(iFilter, this) > 0;

	iOwner->iCache->GetServerAddress(iOwner->iServerManager.NameSpace(iFilter, iCurrentServer), tmp);

	iFilter.iServerId = iOwner->iServerManager.ServerId(tmp);

	iCurrentServer = iOwner->iServerManager.Next(iFilter, 0);

#ifdef _LOG

	if (iCurrentServer)

		Log::Printf(_L("\t\tDNS session [%u] default nameserver (id=%d) assigned"), (TInt)this, (TInt)iCurrentServer);

	else

		Log::Printf(_L("\t\tDNS session [%u] no nameservers available for this session"), (TInt)this);

#endif

	return ret || iCurrentServer != 0;

	}

// TDndReqData::PickNewServer

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

TBool TDndReqData::PickNewServer()

	{

	if (iCurrentServer == 0)

		iOwner->iServerManager.BuildServerList();

	iCurrentServer = iOwner->iServerManager.Next(iFilter, iCurrentServer);

#ifdef _LOG

	if (iCurrentServer)

		Log::Printf(_L("\t\tDNS session [%u] next nameserver (id=%d) assigned"), (TInt)this, (TInt)iCurrentServer);

	else

		Log::Printf(_L("\t\tDNS session [%u] next, no alternate nameservers to assign"), (TInt)this);

#endif

	return iCurrentServer != 0;

	}

void TDndReqData::ServerListComplete(const TDnsServerFilter &aFilter, TInt aResult)

	{

	if (&aFilter == &iFilter)

		{

		iCurrentServer = iOwner->iServerManager.Next(iFilter, 0);

		if (iIsReqPending)

			{

			if (aResult == KErrNone)

				{

				if (PickDefaultServer())

					{

					iOwner->ReSend(*this);

					aResult = KDnsNotify_HAVE_SERVERLIST;

					}

				else

					aResult = KErrDndServerUnusable;

				}

			SendResponse(aResult);

			}

		}

	}

// CDndDnsclient::OpenSession

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

/**

// A session is internally represented by a TDndReqData. Find an unused

// entry and assign it. Unused entry is recognized by it having no

// callback function (= NULL).

*/

MDnsSession *CDndDnsclient::OpenSession(MDnsResolver *const aCallback)

	{

	TUint i;

	//

	// Locate available TDndReqData entry...

	//

	for (i = 0;; ++i)

		{

		if (i >= KDndNumRequests)

			return NULL;	// No "sessions" available

		// For now, assume the slot is available, if no callback has been installed

		if (iDndReqData[i].iCallback == NULL)

			break;

		}

	TDndReqData &rq = iDndReqData[i];

	rq.iCallback = aCallback;

	rq.iOwner = this;

	iActivityCount++;	// Count each open session as "activity".

	return &rq;

	}

void CDndDnsclient::Error(const TInetAddr &aServer, TInt /*aError*/)

	{

	const TUint server_id = iServerManager.ServerId(aServer);

	if (server_id == 0)

		return;		// -- nothing to do, address not registered as a server

	//

	// Try to notify all sessions currently using this server

	//

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

		{

		TDndReqData &rq = iDndReqData[i];

		// For now, assume the slot is in used, if callback has been installed

		if (rq.iCallback == NULL)

			continue;

		if (rq.iCurrentServer == server_id)

			rq.SendResponse(KErrDndServerUnusable);

		}

	}

// TDndReqData::Close

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

void TDndReqData::Close()

	{

	CancelQuery();

	iCallback = NULL;

	if (iRecord)

		{

		iRecord->Unlock(this);

		iRecord = NULL;

		}

	iOwner->iServerManager.CloseList(iFilter);

	// If this was the last active session, then

	// cancel all requests 

	ASSERT(iOwner->iActivityCount > 0);

	if (--iOwner->iActivityCount == 0)

		iOwner->DeactivateSocket();

	}

// TDndReqData::NewQuery

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

TInt TDndReqData::NewQuery(const TDnsMessage &aQuery, TDnsServerScope aServerScope, TUint32 aFlags)

	{

	iIsReqPending = FALSE;

	iIsNewQuery = TRUE;

	iIsUsingTCP = 0;

	iQdCount = 1;

	iFlags = aFlags;

	iFilter.iServerScope = aServerScope;

	iFilter.iServerId = 0;

	iNetworkId = aQuery.iId;  // Get the networkId information from the Query.

#ifdef SYMBIAN_DNS_PUNYCODE

	if( (aQuery.iScope & 0x80) == 0x80 )

		{

		iIdnEnabled = 1;

		iQuestion.EnableIdn(ETrue);

		}

	else 

		{

		iIdnEnabled = 0;

		iQuestion.EnableIdn(EFalse);

		}

#endif //SYMBIAN_DNS_PUNYCODE

	switch (aQuery.iType)

		{

		case KDnsRequestType_GetByName:

		case KDnsRequestType_GetByAddress:

			{

			const TNameRecord &query = aQuery.NameRecord();

			if (aQuery.iType == KDnsRequestType_GetByName)

				{

				iFilter.iLockId = aQuery.iId;

				iFilter.iLockType = KIp6AddrScopeNetwork;

#ifdef SYMBIAN_DNS_PUNYCODE

				TInt err = iQuestion.SetName(query.iName);

				if( err != KErrNone)

					{

					return err;

					}

#else

				iQuestion.SetName(query.iName);

#endif // SYMBIAN_DNS_PUNYCODE

				}

			else

				{

				iOwner->iServerManager.LockByAddress(TInetAddr::Cast(query.iAddr), aQuery.iId, iFilter);

#ifdef SYMBIAN_DNS_PUNYCODE

				TInt err = iQuestion.SetName(TInetAddr::Cast(query.iAddr));

				if( err != KErrNone)

					{

					return err;

					}

#else

				iQuestion.SetName(TInetAddr::Cast(query.iAddr));

#endif // SYMBIAN_DNS_PUNYCODE

				}

			}

			break;

		case KDnsRequestType_TDnsQuery:

			{

			const TDnsQuery &query = aQuery.Query();

			iQuestion.Copy(query.Data());

			iFilter.iLockId = aQuery.iId;

			iFilter.iLockType = KIp6AddrScopeNetwork;

			}

			break;

		default:

			return KErrNotSupported;

		}

	iCurrentServer = 0;

	//

	// For forward query, the Scope identifier of the aQuery.iAddr is the network id

	// For pointer query, if the address is not of network scope, then need to find

	// the network id based on the scope id... (fix later). -- msa

	iOpcode = EDnsOpcode_QUERY;		// Only EStandard supported! (EInverse is not same as PTR query!!!)

	if (iRecord)

		{

		iRecord->Unlock(this);

		iRecord = NULL;

		}

	return KErrNone;

	}

// TDndReqData::CancelQuery

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

void TDndReqData::CancelQuery()

	{

	iIsReqPending = FALSE;

	Cancel();

	iOwner->iServerManager.CloseList(iFilter);

	}

// TDndReqData::DoNext

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

/**

// @retval aReply	returns the requested Resource Record value, if KErrNone return

// @param aNext		the index of the value to be returned. 0 is the index of the first value

// @returns

//	@li	KErrNotFound, if there is no value at specified index

//	@li	KErrDndCache, if the reply from DNS stored in cache was corrupt

//	@li	KErrNone, if value successfully returned

*/

TInt TDndReqData::DoNext(TDnsMessageBuf &aReply, TInt aNext) const

	{

	if (iRecord == NULL)

		return KErrNotFound;

	TInt ret = iRecord->ErrorCode();

	if (ret < 0)

		return ret;	// No usable record present

	TDndRR tempRR(iRecord->Reply());