// 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_sock.cpp - the main client module of the DNS.

//

#include <e32math.h>

#include <networking/dnd_err.h>

#include <in_sock.h>

#include "dns_sock.h"

#include "message.h"

#include "inet6log.h"

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY 

#include <es_enum.h>

#endif

/**

* Max number of consecutive RunL() calls with error condition.

* When this limit is exceeded, the socket it closed.

*/

const TUint KSocketErrorLimit = 20;

//seeds cannot be negative number. Need mask to seed to positive number.

const TInt KNegativeNumberMask = -1;

//

// TRequestQueue

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

//

class TRequestQueue : public TDblQue<TDnsRequest>

	{

public:

	// Construct an empty request queue

	TRequestQueue();

	// Construct new request queue and MOVE all requests from another into it

	TRequestQueue(TRequestQueue &);

	// Remove the first request from a queue, return NULL if queue is empty

	TDnsRequest *Remove();

	};

TRequestQueue::TRequestQueue()

	: TDblQue<TDnsRequest>(_FOFF(TDnsRequest, iQueueLink))

	{

	}

TRequestQueue::TRequestQueue(TRequestQueue &aQueue)

	: TDblQue<TDnsRequest>(_FOFF(TDnsRequest, iQueueLink))

	{

	if (aQueue.IsEmpty())

		Reset();

	else

		{

		iHead = aQueue.iHead;

		iHead.iPrev->iNext = &iHead;

		iHead.iNext->iPrev = &iHead;

		}

	aQueue.Reset();

	}

TDnsRequest *TRequestQueue::Remove()

	{

	if (!IsEmpty())

		{

		TDnsRequest *rq = First();

		rq->iQueueLink.Deque();

		return rq;

		}

	return NULL;

	}

class CDnsSocketReader;

// CDnsSocketWriter

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

// Internal "hidden" class to do all the work

class CDnsSocketWriter : public CActive

    {

	CDnsSocketWriter(CDnsSocket &aMaster);

public:

	~CDnsSocketWriter();

	void ConstructL();

	// Create a basic (UDP) reader/writer (not activated)

	static CDnsSocketWriter *NewL(CDnsSocket &aMaster, TInt aTTL);

	// Create a TCP writer/reader (not activated)

	static CDnsSocketWriter *NewTcpL(CDnsSocket &aMaster, const TInetAddr &aServer, TInt aTTL);

	// Create a TCP listening writer/reader (not activated)

	static CDnsSocketWriter *NewTcpListenL(CDnsSocket &aMaster, TInt aTTL);

	// Test if a address matches current connection

	TBool Match(const TInetAddr &aServer) const;

	// (Re)Queue the request for processing with new ID

	void Queue(TDnsRequest &aRequest, const TInt aId = -1);

	// Cancel the request and dequeue it

	void Remove(TDnsRequest &aRequest);

	// Change the bind port (and address if specified)

	void SetBind(const TInetAddr &aBind);

	// Set hoplimit for for transmitted packets.

	void SetHoplimit(const TInt aTTL);

	 // Open and activate the UDP socket for DNS traffic (unless already done)

	TInt ActivateSocket();

	// Process socket errors

	TInt HandleError(TInt aReason, const TInetAddr *aServer = NULL);

	// Close and deactivate the UDP socket for DNS traffic

	// Handle receive compeleted, keep receiver active

	void RunReader(const TMsgBuf &aMsg, const TInetAddr &aFrom);

	// Handle send completed, keep sender active (if work to do)

	void RunWriter(TRequestStatus &aStatus);

 	//seed id generator

 	TInt64 SeedIdGenerator(TInt64 aSequence);

	// Return a reference to the RSocket

	inline RSocket &Socket() { return iSocket; }

	inline TBool IsTCP() const { return iTCP != 0; }

	inline TBool IsListen() const { return iListen != 0; }

	inline TBool IsOpened() const { return iOpened; }

	inline void ResetErrorCount() { iErrorCount = 0;}

	// A link chain used by the CDnsSocket to keep track of multiple writers

	CDnsSocketWriter *iNext;

private:

	void RunL();

	void DoCancel();

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY	

	TBool CanUseConnection();

#endif

	CDnsSocket &iMaster;		//< The connection to the CDnsSocket owning this

	RSocket iSocket;			//< The DNS socket

	TUint iDeactivateCount;		//< Count number of deactivations (needed in reply processing)

	TUint iErrorCount;			//< Count number of consecutive errors in RunL (read and write)

	TUint iListen;				//< = 1, if socket is listening TCP socket, waiting on accept.

	TUint iTCP;					//< = 1, if socket is a connected TCP socket

	TUint iOpened:1;			//< = 1, if the socket is open

	TUint iRunWriter:1;			//< = 1, if executing RunWriter (callback safeguard)

	TUint iRunReader:1;			//< = 1, if executing RunReader (callback safeguard)	

	TInt iTTL;					//< The TTL/Hoplimit to be used

	TInt64 iSequence;			//< Used in computing the ID value for the queries

	TBuf8<KDnsMaxMessage> iOutMsg;	//< For sending the outgoing message

	TInetAddr iBind;			//< Address/Port to bind the socket.

	TInetAddr iTo;				//< Filled with the destination address of the query

	TRequestQueue iSendQueue;	//< Requests waiting to be sent

	TRequestQueue iWaitQueue;	//< Requests waiting for a reply

	TDnsRequest *iSending;		//< The request currently being sent, if non-NULL

	CDnsSocketReader *iReader;	//< The reader object

	};

void TDnsRequest::Cancel()

	{

	CDnsSocketWriter *const writer = iQueueLink.Writer();

	if (writer)

		writer->Remove(*this);

	}

// CDnsSocketReader

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

// Internal "hidden" class for hanlding asynchronous reading

class CDnsSocketReader : public CActive

	{

	friend class CDnsSocketWriter;

public:

	CDnsSocketReader(CDnsSocketWriter &aWriter);

	~CDnsSocketReader();

	void ConstructL(TUint aDnsMaxMessage);

	void Activate();

private:

	void RunL();

	void DoCancel();

	CDnsSocketWriter &iWriter;

	TUint iReadLength:1;

	TInetAddr iFrom;		//< Filled with source address of a received packet

	HBufC8 *iInMsg;			//< The real allocated buffer

	TInt iAllocatedLength;	//< The real max length of the buffer

	TPtr8 iBuf;				//< The current receive buffer

	};

	{

	LOG(Log::Printf(_L("CDnsSocketWriter[%u]::CDnsSocketWriter([%u])"), this, &aMaster));

	CActiveScheduler::Add(this);

	TTime seed;

	seed.UniversalTime();

	iSequence = seed.Int64();

	}

void CDnsSocketWriter::ConstructL()

	{

	iReader = new (ELeave) CDnsSocketReader(*this);

	iReader->ConstructL(iMaster.iMaxDnsMessage);

	}

CDnsSocketWriter *CDnsSocketWriter::NewL(CDnsSocket &aMaster, TInt aTTL)

	{

	CDnsSocketWriter *const writer = new (ELeave) CDnsSocketWriter(aMaster);

	CleanupStack::PushL(writer);

	writer->iTTL = aTTL;

	writer->ConstructL();

	CleanupStack::Pop();

	return writer;

	}

CDnsSocketWriter *CDnsSocketWriter::NewTcpL(CDnsSocket &aMaster, const TInetAddr &aServer, TInt aTTL)

	{

	CDnsSocketWriter *const writer = NewL(aMaster, aTTL);

	// Note: with TCP iTo is dummy!

	writer->iTo = aServer;

	writer->iTCP = 1;

	return writer;

	}

CDnsSocketWriter *CDnsSocketWriter::NewTcpListenL(CDnsSocket &aMaster, TInt aTTL)

	{

	CDnsSocketWriter *const writer = NewL(aMaster, aTTL);

	writer->iTCP = 1;

	writer->iListen = 1;

	return writer;

	}

CDnsSocketWriter::~CDnsSocketWriter()

	{

	// As this class is managed by CDnsSocket, it is impossible

	// to get here if IsActive(), or with requests in any queue.

	// (DeactivateSocket is ALWAYS called before destructor)

	//

	ASSERT(!IsActive());

	ASSERT(iSendQueue.IsEmpty());

	ASSERT(iWaitQueue.IsEmpty());

	delete iReader;

	Cancel();	// should not be needed...

	if (IsAdded())

		Deque();

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY		

	iAttachedConn.Close();

#endif	

	LOG(Log::Printf(_L("CDnsSocketWriter[%u]::~CDnsSocketWriter()"), this));

	}

TBool CDnsSocketWriter::Match(const TInetAddr &aServer) const

	{

	// The match applies only to connected TCP readers/writers

	return iTCP && !iListen && aServer.CmpAddr(iTo) && aServer.Scope() == iTo.Scope();

	}

//

// RunReader

//

void CDnsSocketWriter::RunReader(const TMsgBuf &aMsg, const TInetAddr &aFrom)

	{

	if (iRunReader)

		return;

	iRunReader = 1;

#ifdef _LOG

		{

		TBuf<50> tmp;

		aFrom.OutputWithScope(tmp);

		Log::Printf(_L("CDnsSocketWriter[%u]::RunReader() read %d bytes from %S#%d"), this, (TInt)aMsg.Length(),

			&tmp, aFrom.Port());

		}

#endif

	if (aMsg.Length() >= TInt(sizeof(TDndHeader)))

		{

		const TDndHeader &hdr = aMsg.Header();

		const TUint16 id = (TUint16)hdr.ID();

		if (hdr.QR())

			{

			//

			// This is a reply message, match it with

			// a waiting request, if any...

			//

			// Things get somewhat tricky, because almost anything

			// can happen inside the Reply (like DeactivateSocket,

			// ActivateSocketL, removal of any requests, requeing

			// for sent, etc...

			// Grab the current list into separate list. Note, that

			// Query or Reply callbacks are allowed to remove entries

			// from this temporary queue (the TDnsRequest::Cancel and

			// CDnsSocket::Redmove() still work correctly--they don't

			// care which chain the request belongs!),

			TRequestQueue reply(iWaitQueue);

			TUint mark = iDeactivateCount;

			TDnsRequest *rq;

			for (;;)

				{

				rq = reply.Remove();

				if (rq == NULL)

					{

					// Didn't match any request, punt it into Query()

					iMaster.Query(aMsg, aFrom, iSocket);

					break;

					}

				iWaitQueue.AddLast(*rq);

				if (rq->iId == id && rq->Reply(iMaster, aMsg, aFrom))

					break;

				}

			if (iDeactivateCount == mark)

				{

				//

				// No socket shutdown occurred, just reinsert remaining requests

				//

				while ((rq = reply.Remove()) != NULL)

					iWaitQueue.AddLast(*rq);

				}

			else

				{

				//

				// Socket was shut within Reply, all requests

				// should have been cancelled then...

				//

				while ((rq = reply.Remove()) != NULL)

					{

					rq->iQueueLink.SetWriter(NULL);

					rq->Abort(iMaster, KErrCancel);

					}

				}

			}

		else

			{

			//

			// Not a reply message, let the derived

			// class decide on how to deal with it.

			//

			iMaster.Query(aMsg, aFrom, iSocket);

			}

		}

	iRunReader = 0;

 	if (iOpened ) 	// still open for business?

		{

		// Start a new read

		iReader->Activate();

		}

	}

void CDnsSocketWriter::Queue(TDnsRequest &aRequest, TInt aId)

	{

	aRequest.Cancel();

	//

	// Assign a new random ID for the request

	//

	if (aId < 0)

 		{

 		TInt64 seed = SeedIdGenerator(iSequence);

 		if(seed<0)

 		seed = seed *(KNegativeNumberMask);

 		aRequest.iId = (TUint16)(Math::Rand(seed) >> 8);

 		}

	else

		aRequest.iId = (TUint16)aId;

	aRequest.iQueueLink.SetWriter(this);

	iSendQueue.AddLast(aRequest);

	LOG(Log::Printf(_L("\t\tDNS session [%u] Queued for send with ID=%d"), (TInt)&aRequest, (TInt)aRequest.iId));

	if (!IsActive())

		RunWriter(iStatus);

	}

void CDnsSocketWriter::SetBind(const TInetAddr &aBind)

	{

	iBind = aBind;

	}

void CDnsSocketWriter::SetHoplimit(const TInt aTTL)

	{

	if (aTTL != iTTL)

		{

		iTTL = aTTL;

		iSocket.SetOpt(KSoIp6UnicastHops, KSolInetIp, iTTL);

		iSocket.SetOpt(KSoIp6MulticastHops, KSolInetIp, iTTL);

		}

	}

TInt CDnsSocketWriter::ActivateSocket()

	{

 	if (iOpened) 

		return KErrNone;		// Nothing to do if already opened

	iErrorCount = 0;

#ifndef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY 	

	TInt err = 

		iListen ? iSocket.Open(iMaster.iSS) :

		iTCP ? iSocket.Open(iMaster.iSS, KAfInet, KSockStream, KProtocolInetTcp) :

		iSocket.Open(iMaster.iSS, KAfInet, KSockDatagram, KProtocolInetUdp);

#else			

	TInt err = KErrNone;

	if (iListen)

		{

		err = iSocket.Open(iMaster.iSS);	

		}

	else

		{		

		TUint addrFamily = iTCP ? KSockStream : KSockDatagram;

		TUint protocol = iTCP ? KProtocolInetTcp : KProtocolInetUdp;

		if (CanUseConnection())

			{

			err = iSocket.Open(iMaster.iSS, KAfInet, addrFamily, protocol, iAttachedConn);

			}

		else

			{

			err = iSocket.Open(iMaster.iSS, KAfInet, addrFamily, protocol);	

			}			

		}

#endif			

#ifdef _LOG

	// Initialize for LOG prints

	TBuf<50> tmp;

	iBind.OutputWithScope(tmp);

#endif

	if (err == KErrNone)

		{

		if (iListen || (err = iSocket.Bind(iBind)) == KErrNone)

			{

			iOpened = 1;

			if (iListen)

				{

				LOG(Log::Printf(_L("CDnsSocketWriter[%u]::ActivateSocketL() listening %S#%d"), this, &tmp, iBind.Port()));

				iMaster.iListener.Accept(iSocket, iStatus);

				SetActive();

				}

			else

				{

				iSocket.SetOpt(KSoIp6UnicastHops, KSolInetIp, iTTL);

				iSocket.SetOpt(KSoIp6MulticastHops, KSolInetIp, iTTL);

				if (iTCP)

					{

#ifdef _LOG

					TBuf<50> dst;

					iTo.OutputWithScope(dst);

					Log::Printf(_L("CDnsSocketWriter[%u]::ActivateSocketL() TCP connect src=%S#%d dst=%S#%d"), this,

						&tmp, iBind.Port(),

						&dst, iTo.Port());

#endif

					iSocket.Connect(iTo, iStatus);

					SetActive();

					}

				else

					{

					LOG(Log::Printf(_L("CDnsSocketWriter[%u]::ActivateSocketL() UDP %S#%d"), this, &tmp, iBind.Port()));

					iSocket.SetOpt(KSoUdpReceiveICMPError, KSolInetUdp, 1);

					if (!iRunReader)

						iReader->Activate();

					}

				}

			return KErrNone;

			}

		iSocket.Close();

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY		

		iAttachedConn.Close();

#endif		

		}

	// Should probably be logged in release too!

	LOG(Log::Printf(_L("CDnsSocketWriter[%u]::ActivateSocketL() bind=%S#%d (or open) failed %d"), this, &tmp, iBind.Port(), err));

	return err;

	}

/**

* Decides on action when the socket returns an error status. Not all

* errors are fatal errors, which require a reset of the socket.

*

* @param aReason	the error code from the socket (iStatus)

* @param aServer	the dns server address, if known (only for Send errors)

*

* @return

* @li	= 1, Error fully processed, Don't activate anything

* @li	= 0, Error handled, keep CActive running

*/

TInt CDnsSocketWriter::HandleError(TInt aReason, const TInetAddr *aServer)

	{

	if (++iErrorCount > KSocketErrorLimit)

		{

		// Too many consecutive errors, deactivate to reset

		LOG(Log::Printf(_L("CDnsSocketWriter[%u]::HandleError(%d) Too many (%d) consecutive errors"), this, aReason, iErrorCount));

		DeactivateSocket(aReason);

		return 1;

		}

	if (IsTCP())

		{

		// Any error on TCP socket means that it is "dead",

		// and we must close the socket to recover!

		DeactivateSocket(KErrDndServerUnusable);

		return 1;

		}

	// The error state should automaticly clear with datagram

	// sockets, but in some releases it does not. Issue a

	// dummy KSOSelectLastError, which in some cases also

	// clears the error code from socket server. (Note: the