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

// resolver.cpp - name resolver

//

#include <in_sock.h>

#include <timeout.h>

#include "listener.h"

#include "resolver.h"

#include "engine.h"

#include "hosts.h"

#include <networking/dnd_err.h>

#include "dns_ext.h"

#include "inet6log.h"

#ifdef DND_DCM_EXTENSION

#include "dnd.hrh"		// EDndFlush

#endif

#ifdef EXCLUDE_SYMBIAN_DNS_PUNYCODE

#undef SYMBIAN_DNS_PUNYCODE

#endif //EXCLUDE_SYMBIAN_DNS_PUNYCODE

struct SQueryStep

	{

	EDnsQType iQType;			// the query type

	};

struct SQueryExtension

	{

	const TDesC *iPrefix;

	SQueryStep iQuery;

	};

// ...for GetByAddr, perform only PTR query (for each server)

const SQueryStep KGetByAddress[1] =

	{

	{ EDnsQType_PTR }

	};

// ...for GetByName, try first AAAA and then A (for each server)

const SQueryStep KGetByName1[2] =

	{

	{ EDnsQType_AAAA },

	{ EDnsQType_A }

	};

// ...for GetByName, try first A and then AAAA (for each server)

const SQueryStep KGetByName2[2] =

	{

	{ EDnsQType_A },

	{ EDnsQType_AAAA }

	};

// Define the search order of the sources

const TDnsServerScope KSourceOrder[] =

	{

	EDnsServerScope_HOSTFILE,	// 1. Search hosts file first

	EDnsServerScope_UC_GLOBAL,	// 2. Search global DNS

#ifdef LLMNR_ENABLED

	EDnsServerScope_MC_LOCAL,	// 3. Try Link Local Multicast

#endif

	};

const SQueryExtension KQueryExtension[] =

	{

#if 0

	{ &KDnsExtQType_A,		EDnsQType_A },

	{ &KDnsExtQType_AAAA,	EDnsQType_AAAA },

	{ &KDnsExtQType_MX,		EDnsQType_MX },

	{ &KDnsExtQType_NS,		EDnsQType_NS },

	{ &KDnsExtQType_SOA,	EDnsQType_SOA },

	{ &KDnsExtQType_CNAME,	EDnsQType_CNAME },

	{ &KDnsExtQType_PTR,	EDnsQType_PTR },

	{ &KDnsExtQType_SRV,	EDnsQType_SRV },

	{ &KDnsExtQType_NAPTR,	EDnsQType_NAPTR },

	{ &KDnsExtQType_ANY,	EDnsQType_ANY }

#else

	// Workaround for ARMV5 compiler bug? Above declaration always

	// produces 80 bytes of writable global data. The following

	// ugly definition does not.

	{ (const TDesC *)&KDnsExtQType_A.iTypeLength,		EDnsQType_A },

	{ (const TDesC *)&KDnsExtQType_AAAA.iTypeLength,	EDnsQType_AAAA },

	{ (const TDesC *)&KDnsExtQType_MX.iTypeLength,		EDnsQType_MX },

	{ (const TDesC *)&KDnsExtQType_NS.iTypeLength,		EDnsQType_NS },

	{ (const TDesC *)&KDnsExtQType_SOA.iTypeLength,		EDnsQType_SOA },

	{ (const TDesC *)&KDnsExtQType_CNAME.iTypeLength,	EDnsQType_CNAME },

	{ (const TDesC *)&KDnsExtQType_PTR.iTypeLength,		EDnsQType_PTR },

	{ (const TDesC *)&KDnsExtQType_SRV.iTypeLength,		EDnsQType_SRV },

	{ (const TDesC *)&KDnsExtQType_NAPTR.iTypeLength,	EDnsQType_NAPTR },

	{ (const TDesC *)&KDnsExtQType_ANY.iTypeLength,		EDnsQType_ANY }

#endif

	};

// KMaxQuerySessions

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

/**

// The maximum number of query sessions for single resolver,

// for example, supporting A and AAAA query, requires this

// to be at least 2.

// (if someone ever adds A6 to the list, it needs to be 3).

*/

const TUint KMaxQuerySessions = 2;

// KMaxDeprecated

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

/**

// The size of the deprecated answers buffer. When processing

// the replies for GetByName, the resolver will first return

// those A and AAAA answers, for which there is an existing

// route and source address in the current system. Other answers

// are put into deprecated buffer, and returned after the

// "good" answers.

*/

const TUint KMaxDeprecated = 20;

class CDndResolver;

/**

// The resolver state automaton for one DNS query.

//

// This executes the state automaton for a single DNS query

// (for example A, AAAA, MX, etc.). The processing includes

// automatic retransmissions (potentially to multiple DNS

// servers) and timeout handling 

//

// The query process is started by Start() and it will

// then proceed independently to the conclusion.

// When the query has completed or failed,

// CDndResolver::GetNextAnswer() is called.

//

// In some cases an error is considered to be non-recoverable,

// and instead of calling GetNextAnswer(), CDndResolver::QueryDone(error)

// is called instead. This cancel the main query processing and

// return the indicated error directly to the client process

// (RHostResolver).

//

*/

class TQuerySession: public MDnsResolver

	{

	friend class TQuerySessionTimeoutLinkage;

public:

	// Default constructor

	TQuerySession();

	// Supplement default constructor

	void Init(CDndResolver *const aResolver);

	// Open a new session to the DNS handler

	void Open();

	// Close the session with the DNS handler

	void Close();

	// Start a DNS query on the session

	TBool Start(EDnsQType aQType);

	MDnsSession *iSession;		//< Session handle with DndDnsclient

	TInt iStatus;				//< Session status / next record to retrieve (if >= 0)

	EDnsQType iQType;			//< the query type

private:

	static inline TInt Max(const TInt a, const TInt b) { return a > b ? a : b;}

	// A callback method when the timeout expires

	void Timeout(const TTime &aNow);

	// Request a call to Timeout after specified time (seconds)

	void SetTimer(TUint aTimeout);

	// A callback method when the request to DNS handler completes

	void ReplyCallback(const TInt aErr);

	// Cancel pending operations

	void Cancel();

	// Activate a query in the DNS handler

	void SendDnsQuery();

	// Internal, handles the common part of timeout and reply callbacks

	void Event(TBool aTimeout);

	CDndResolver *iResolver;	//< The back pointer to resolver

	TUint8 iQueryRetry;			//< Current retry index (for the current step)

	TUint8 iQueryTimeouts;		//< Number of true timeouts (used by some resolver modes)

	TUint8 iServerCount;		//< used in "spray mode" to count the servers.

	TUint iWaitingQuerySent:1;	//< used in detecting and timing out interface startup.

	TUint iWaitingAfterSpray:1;	//< used only in "spray mode"

	TUint iSendingQuery:1;		//< set to 1, when DoQueryL is being called (recursion safeguard in SendDnsQuery)

	TUint iPendingQuery:1;		//< set to 1, when DoQueryL is required (recursion safeguard in SendDnsQuery)

	TUint iQueryTimeoutValue;	//< The current timeout for waiting the reply AFTER packet is sent

public:	// Needed for gcc!

	RTimeout iTimeout;

#ifdef _LOG

	TBuf<2> iName;

#endif

	};

// This ungainly manoevure is forced on us because the offset is not evaluated early enough by GCC3.4 to be

// passed as a template parameter

#if defined(__X86GCC__) || defined(__GCCE__)

#define KQuerySessionTimeoutLinkageOffset 28

__ASSERT_COMPILE(KQuerySessionTimeoutLinkageOffset == _FOFF(TQuerySession, iTimeout));

#else

#define KQuerySessionTimeoutLinkageOffset _FOFF(TQuerySession, iTimeout)

#endif

class TQuerySessionTimeoutLinkage : public TimeoutLinkage<TQuerySession, KQuerySessionTimeoutLinkageOffset>

	{

public:

	static void Timeout(RTimeout &aLink, const TTime &aNow, TAny * /*aPtr*/)

		{

		Object(aLink)->Timeout(aNow);

		}

	};

/**

// A structure to remember an answer to be retrieved later.

*/

class TDeprecatedAnswer

	{

public:

	inline TDeprecatedAnswer() {}

	inline TDeprecatedAnswer(TUint8 aStep, TUint8 aIndex) : iStep(aStep), iIndex(aIndex) {}

	TUint8 iStep;		//< query step # (selects session)

	TUint8 iIndex;		//< answer index within the query reply

	};

/**

The real implementation of the MDndResolver.

Function:

@li	Accepts the request (see TDnsRequestBase) from the application for name resolving.

@li	Tries to resolve the request from host files or DNS sources

@li	Once the request is over (response obtained or time out),

	it sends back the response (again TDnsRequestBase) and/or error code

	to the application which requested it.

See also \ref resolvers

This class is designed so that it can be reused for serving

different clients. It has the following simplified state diagram:

@verbatim

                   _________________________

                 /      reuse               \

                V                            |

 construct -> Start() ---> WaitQuery() --> Stop() --> destruct

                               /  \          ^

                              |    |         |

                               \  /         /

                            QueryDone() ___/

@endverbatim

@li Start()

	serving a specific RHostResolver session. This method is called

	from CDndListener, after it has received a new query request

	from the stack.

@li WaitQuery()

	the resolver is waiting for next incoming request

	from the RHostResolver.

@li QueryDone()

	queue a result to be returned to the RHostResolver.

@li Stop()

	serving the current rquest. This may be called either

	internally or from CDndListener.

*/

class CDndResolver : public CBase, public MDndResolver, public MDnsResolver

	{

	friend class TQuerySession;

public:

	CDndResolver(const TInt aId, CDndEngine &aControl, MDndListener &aListener, 

					MDnsSource &aDnsclient);

	void Start(const TDnsMessageBuf &aMsg);	// Starts the resolver

	const TDesC8 &ReplyMessage();			// Return reference to the reply buffer.

	TUint16 Session() const;				// Return session id of the current query.

	void Stop();							// Stop the resolver

	virtual ~CDndResolver();

	static inline TInt Max(const TInt a, const TInt b) { return a > b ? a : b;}

	const TTime &RequestTime() const { return iRequestTime; }

	// only used for GetHostName

	void ReplyCallback(const TInt aResult);

private:

	// Return a result to the application

	void QueryDone(TInt aResult);

	// Wait for the next query from the application

	void WaitQuery();

	// Select next source for the name resolving (HOSTS, DNS, LLMNR)

	void NextSource();

	// Cancel all activity and resources being used for the current source

	void StopSource();

	TBool StartSource();

	// Return next result from HOSTS file source

	void HOSTFILE_Next();

#ifdef _LOG

	// Print out debugging information

	void ShowQuery(const TDnsMessage &aName, TInt aReply);

#endif

	// Retrieve next answer, possibly starting retrieval of additional information from source

	void GetNextAnswer();

	// Used to find alternate DNS servers (in some operating modes)

	void ProbeServers();

private:

	const TInt iId;					//< Resolver instance id (for debugging use)

	TTime iRequestTime;				//< Time at which the request was received from the application

	// The Query buffer for the reply

	TDnsMessageBuf iBuffer;

	// The current orignal query being processed.

	TDnsMessageBuf iCurrentQuery;

	const TDnsServerScope *iSourceList;	//< Information sources

	TDnsServerScope iSourceNow;		//< The current source

	TUint iQueryStepMaxTime;		//< Maximum time allowed for single query step to complete

	TUint iQueryStepMinTime;		//< Minimum time for query step (usage depends on mode)

	TUint8 iQueryStepRetries;		//< Additional retries after the primary attempt

	TInt iSourceCount;				//< Remaining number of sources.

	TInt iNext;						//< Non-zero, if executing Next operation

	// Specify Current Query state

	const SQueryStep *iQueryStep;	//< The Current Query Process (what queries to make)

	SQueryStep iSpecificQuery;		//< Used in implementing the Specific Single Queries

	TQuerySession iSession[KMaxQuerySessions]; //< Currently active queries or completed results

	TDeprecatedAnswer iDeprecate[KMaxDeprecated];	//< Buffer to store the delayed answers

	TUint iPhase;

	TUint8 iDeprecatedTop;		//< Number of delayed top answers in iDeprecate[]

	TUint8 iDeprecatedBottom;	//< Number of delayed bottom answers in iDeprecate[]

	TUint8 iQuerySteps;			//< Number of Query Steps in the process

	TUint8 iStepCount;			//< Number of Query Steps activated so far

	TUint8 iSessionCount;		//< Number of Query Sessions currently active

	/*

	// The scope level of the current query.

	//

	// Currently the level for GetByName and Query is always "NETWORK".

	// But, if implemented, it could be "LINK LOCAL", based on the

	// queried name, for example, if it ends with ".local".

	//

	// The level of GetByAddress is the scope level of the address being

	// queried.

	//

	// The query scope limits the sources available to the query: the scope

	// of the source must be less or equal to the query scope. (For example,

	// GetByAddress for a link local address is only asked from link local

	// name resolvers).

	*/

	TUint8 iQueryScope;

	TUint iQueryActive:1;		//< set to 1, when a query is being processed

	TUint iQueryIsAddr:1;		//< set to 1, when current query is GetByAddr, = 0, otherwise

	TUint iQueryIsSpecial:1;	//< set to 1, when current query is special (for exact DNS query type)

	TUint iReadyForAnswer:1;	//< set to 1, when an answer can be delivered back to RHostResolver.

	TUint iQueryDoneWait:1;		//< Tells what active object is currently waiting: = 0, if WaitQuery, = 1, if QueryDone

	TUint iQueryComplete:1;		//< set to 1, when query is completed fully (no Next allowed)

	TUint32 iQueryFlags;		//< Flags to the NewQuery (KDnsMofidier_RD, ...)

	TQuerySession iProbe;		//< Use for server probing

	CDndEngine &iControl;		//< The control context (for sending errors etc.)

	MDndListener &iListener;	//< Only for calling KeepRunning()

	MDnsSource &iDnsclient;		//< DNS protocol handler

	};

// CDndResolverBase::New

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

MDndResolver *MDndResolver::New(const TInt aId, CDndEngine &aControl, MDndListener &aListener, MDnsSource &aDnsClient)

	/**

	* Create a new instance of CDndResolver.

	*

	* This static function creates the real object instance of

	* the class that has been derived from CDndResolverBase.

	*

	* This way, the real implementation of the class is hidden

	* from any other module (the real class CDndResolver is only

	* declared and known within resolver.cpp module).

	*

	* @param aId identifies the resolver instance (only for debuggind purpose)

	* @param aControl provides access to the DND environment

	* @param aListener

	*	provides access to the socket listener, which manages the

	*	pool of CDndResolver instances and delivers the requests

	*	to the resolvers.

	* @param aDnsClient

	*	provides access to the DNS protocol driver, which implements

	*	the DNS protocol details, and manages the associated UDP and

	*	TCP sockets.

	* @return

	*	@li	NULL, if object could not be created (out of memory)

	*	@li non-NULL, is a pointer to the newly constructed CDndResolver instance

	*/

	{

	return new(ELeave) CDndResolver(aId, aControl, aListener, aDnsClient);

	}

// Constructor

CDndResolver::CDndResolver(const TInt aId, CDndEngine &aControl, MDndListener &aListener, MDnsSource &aDnsclient)

	: iId(aId), iControl(aControl), iListener(aListener), 

	  iDnsclient(aDnsclient)

	{

	// Because array elements cannot have other than default constructors,

	// need to initialize the iSession[] and iProbe here..

	for (TInt i = KMaxQuerySessions; --i >= 0; )

		{

		iSession[i].Init(this);

		LOG(iSession[i].iName.Format(_L("%d"), i));

		}

	iProbe.Init(this);

	LOG(iProbe.iName = _L("*"));

	}

// Destructor

CDndResolver::~CDndResolver()

	{

	// Need to cancel TQuerySession's (if any active)

	for (TInt i = KMaxQuerySessions; --i >= 0; )

		iSession[i].Close();

	}

#ifdef _LOG

// CDndResolver::ShowQuery(aName)

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

void CDndResolver::ShowQuery(const TDnsMessage &aPacket, TInt aReply)

	/**

	* Displays the current query or reply (only a debugging tool).

	*

	* @param	aPacket	Query or Reply data

	* @param	aReply	Query vs. reply

	*/

	{

	_LIT(KReply, " Reply ");

	_LIT(KQuery, " Query ");

	const TDesC &mode = aReply ? KReply : KQuery;

	switch (aPacket.iType)

		{

		case KDnsRequestType_GetByName:

		case KDnsRequestType_GetByAddress:

			{

			const TNameRecord &rec = aPacket.NameRecord();

			TBuf<50> tmp;

			TInetAddr::Cast(rec.iAddr).OutputWithScope(tmp);

			if (aReply)

				Log::Printf(_L("\tresolver[%d] SESSION %d Reply [%d], %S, [%S] result=%d"), iId, aPacket.iSession, rec.iFlags, &rec.iName, &tmp, aPacket.iNext);

			else

				Log::Printf(_L("\tresolver[%d] SESSION %d Query (%d), %S, [%S]"), iId, aPacket.iSession, aPacket.iNext, &rec.iName, &tmp);

			}

			break;

		case KDnsRequestType_TDnsQuery:

			{

			if (aReply)

				{

				const TDndReply &reply = aPacket.Reply();

				Log::Printf(_L("\tresolver[%d] SESSION %d Special Reply, type=%d result=%d"), iId, aPacket.iSession, (TInt)reply.RRType(), aPacket.iNext);

				}

			else

				{

				const TDnsQuery &query = aPacket.Query();

				Log::Printf(_L8("\tresolver[%d] SESSION %d Special Query (%d), %S type=%d"), iId, aPacket.iSession, aPacket.iNext, &query.Data(), (TInt)query.Type());

				}

			}

			break;

		case KDnsRequestType_SetHostName:

			Log::Printf(_L("\tresolver[%d] SESSION %d SetHostName(%S)%S%d"), iId, aPacket.iSession, &aPacket.HostName(), &mode, aPacket.iNext);

			break;

		case KDnsRequestType_GetHostName:

			Log::Printf(_L("\tresolver[%d] SESSION %d GetHostName(%S)%S%d"), iId, aPacket.iSession, &aPacket.HostName(), &mode, aPacket.iNext);

			break;

		default:

			Log::Printf(_L("\tresolver[%d] SESSION %d Bad TDnsMessagePacket%S(%d,%d)"), iId, aPacket.iSession, &mode, aPacket.iType, aPacket.iNext);

			break;

		}

	}

#endif

// CDndResolver::Stop

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

void CDndResolver::Stop()

	/**

	* Stop serving the current request.

	*

	* Terminate all pending activity (if any) and mark the

	* CDndResolver instace available for a new session.

	*/

	{

	iReadyForAnswer = 0;		// ...just to be safe.

	StopSource();				// stop all DNS activity related to this client, if any

	if (iQueryActive)

		{

		iQueryActive = 0;

        iDnsclient.QueryEnd();

		}

	LOG(Log::Printf(_L("\tresolver[%d] SESSION %d Stopped"), iId, iCurrentQuery().iSession));

	iCurrentQuery().iSession = 0;

	iQueryDoneWait = 0;

	}

// CDndResolver::WaitQuery

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

void CDndResolver::WaitQuery()

	/**

	* Put the CDndResolver to wait a next request from the RHostResolver.

	*

	* The next request could be a Next, or a new GetByName, GetByAddr or

	* Query.

	*/

	{

	iReadyForAnswer = 0;

	if (iQueryActive)

		{

		// There could be active sessions

		// doing some queries while we wait for

		// client to request something (doing