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

// res.cpp - name resolver

// This is an implementation of the name service, which is based

// on a external resolver application, and translating the queries

// into socket read/writes.

//

/**

 @file res.cpp

*/

#define SYMBIAN_NETWORKING_UPS

#include <in_sock.h>

#include "res.h"

#include <in_bind.h>	// CProtocolBaseUnbind, MInterfaceManager

#include <timeout.h>

#include <in6_event.h>

#include <in6_opt.h>

#include "iface.h"

#include "inet6log.h"

#include "tcpip_ini.h"

#include "networkinfo.h"

#include "res_sock.h"

#include "inet6err.h"

#include <networking/dnd_err.h>

#	include <comms-infras/nifif.h>	// Need for TSoIfConnectionInfo

#include <es_prot_internal.h>

#ifdef SYMBIAN_DNS_PUNYCODE

#define ENABLEIDN_SCOPE 0x80

#endif //SYMBIAN_DNS_PUNYCODE

_LIT_SECURITY_POLICY_C1(KPolicyNetworkControl,  ECapabilityNetworkControl);

_LIT_SECURITY_POLICY_C1(KPolicyNetworkServices, ECapabilityNetworkServices);

class TDnsRequest : public TDnsRequestBase

	/**

	* The internal representation of a pending query from application/SocketServer.

	*/

	{

public:

	TDnsRequest();

	TDnsRequest(const THostName &aName, TDes &aResponse, TInt aType);

	TDnsRequest(TNameRecord &aQuery, TInt aNext, TInt aType);

	TDnsRequest(const TDesC8 &aQuery, TDes8 &aResponse, TInt aNext);

	void BuildMessage(TUint16 aId, TDes8 &aBuffer) const;

	TBool IsPending() const { return iQuery.Length() > 0; }

	TPtrC8 iQuery;		//< The query buffer

	// Reply data

	union

		{

		TUint8 *iResponse;			//< For initializing.

		TNameRecord *iNameRecord;	//< GetByAddr/GetByName

		TDes8 *iQueryResponse;		//< Query response

		TDes *iHostName;			//< GetHostName/SetHostName

		};

	};

// CProtocolRes

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

class CHostResolver;

class CProviderRes;

class CDndSession;

class CProtocolRes : public CProtocolBaseUnbind, public MEventListener

	/**

	* The "resolver protocol".

	*/

	{

	friend class CProviderRes;

	friend class CHostResolver;

public:

	CProtocolRes(CIfManager &aInterfacer);

	virtual ~CProtocolRes();

	virtual CServProviderBase *NewSAPL(TUint aProtocol);

	virtual CHostResolvProvdBase* NewHostResolverL();

	virtual CServiceResolvProvdBase *NewServiceResolverL();

	virtual CNetDBProvdBase *NewNetDatabaseL();

	virtual void Identify(TServerProtocolDesc *) const;

	virtual void BindL(CProtocolBase* protocol, TUint id);

	virtual void Unbind(CProtocolBase* protocol, TUint id);

	virtual void StartL();

	static void FillinInfo(TServerProtocolDesc &anEntry);

	//

	// Resolver specific Methods

	//

	inline MInterfaceManager &Interfacer() const { return iInterfacer; }

	CHostResolver *FindPending() const;

	CProviderRes *NewQuery(CHostResolver *aResolver);

private:

	void CancelSAP(const CProviderRes &aSAP);		// ..for ~CProviderRes() only!

	void CancelQuery(const CHostResolver &aQuery);	// ..for ~CHostResolver() only!

	virtual void Notify(TUint aEventClass, TUint aEventType, const void *aData);

	CProviderRes *iDND;				//< The Domain Name Resolver Daemon (DND)

	CHostResolver *iQueries;		//< List of Queries (RHostResolver sessions)

	CIfManager &iInterfacer;		//< The Interface manager link

	TUint iConfigureDone:1;			//< = 1, when the Configure request has been sent to DND

	};

// CProviderRes

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

class CHostResolver;

class CDndSession;

class CProviderRes: public CServProviderBase

	/**

	* The "DND provider" (SAP).

	*/

	{

	friend class CProtocolRes;

public:

	CProviderRes(CProtocolRes &aProtocol);

	~CProviderRes();

	// 'resolver' has no use for local or remote addresses or ports.

	// (these methods should never be called by DND) .None of the Open's are called

	// (resolver is always "connectionless datagram socket"). Just silence the

	// compiler by defining dummy implementations for all those functions.

	virtual void ActiveOpen() {}

	virtual void ActiveOpen(const TDesC8 &) {}

	virtual TInt PassiveOpen(TUint) { return KErrNone; }

	virtual TInt PassiveOpen(TUint ,const TDesC8 &) { return KErrNone; };

	virtual void LocalName(TSockAddr &) const {}

	virtual TInt SetLocalName(TSockAddr &) { return KErrNone; }

	virtual void RemName(TSockAddr &) const {}

	virtual TInt SetRemName(TSockAddr &) { return KErrNone; }

	virtual void AutoBind() {}

	// These are potentially useful, but don't do much currently

	virtual void Shutdown(TCloseType option,const TDesC8 &aDisconnectionData);

	virtual void Shutdown(TCloseType option);

	virtual TInt GetOption(TUint level,TUint name,TDes8 &anOption) const;

	virtual void Ioctl(TUint level,TUint name,TDes8* anOption);

	virtual void CancelIoctl(TUint aLevel, TUint aName);

	virtual TInt SetOption(TUint level,TUint name, const TDesC8 &anOption);

	// The real "beef"...

	virtual TUint Write(const TDesC8 &aDesc,TUint options, TSockAddr* aAddr=NULL);

	virtual void GetData(TDes8 &aDesc,TUint options,TSockAddr *anAddr=NULL);

	virtual void Start();

	TInt SecurityCheck(MProvdSecurityChecker *aChecker);

	// Resolver methods

	void Unlink();							//< Called by iResolver to remove the iResolver

	void Activate();						//< Used when an attached Session needs servicing.

	TBool AssignSession(CHostResolver &aHR);//< Assign a session for the Host Resolver

	CProtocolRes &iProtocol;				//< Protocol instance of the 'resolver'

protected:

	const CDndSession *Find(const TUint16 aId) const;

	CDndSession *iSessions;					//< List of associated sessions.

	TUint16 iSessionId;						//< Last used session id.

	TInt iAvailable;						//< Available sessions in DND.

	};

// CDndSession

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

class CDndSession : public CBase

	/**

	* The session assigned to the host resolver.

	*

	* When the DND accepts a host resolver to be served,

	* this class is created to represent the session.

	*

	* Note: This is needed separate from the CHostResolver,

	* because

	* - the destruction of host resolver is controlled by the socket server,

	* - after host resolver has been deleted, the cancel message needs to be delivered to DND

	* - when detached from host resolver, this class represents pending session cancel.

	*/

	{

	friend class CProviderRes;

public:

	void Link(CHostResolver &aHR);		//< Attach Host Resolver to session.

	void Unlink();						//< Detach Host Resolver, if any.

	void Reply(const TDnsMessage &aReply, const TDesC8 &aPayload) const;

	void Submit();

	void Answered();

	CDndSession *Delete();				//< Trigger destruction of the session.

	const TUint16 iSessionId;			//< The session id

private:

	CDndSession(CProviderRes &aDnd, TUint16 aId, CDndSession *aNext);

	~CDndSession();						//< Private destructor, delete only from Delete()

	CProviderRes &iDnd;					//< The provider (DND) associated with this session

	CDndSession *iNext;					//< Links sessions under provider together

	CHostResolver *iResolver;			//< Non-null, if this session is (still) associated with RHostResolver

	TTime iAnswerTime;					//< Time of last good answer (only valid if iAnswered == 1).

	TUint iPending:1;					//< = 1, when resolver is pending, and query not yet delivered to DND

	TUint iAnswered:1;					//< = 1, if at least ONE good answer has been returned.

#ifdef SYMBIAN_DNS_PUNYCODE

	TUint iEnableIdn:1;					//< = 1, if support for resolving International Domain Names are enabled

#endif //SYMBIAN_DNS_PUNYCODE

	};

// CHostResolver

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

class CHostResolver : public CHostResolvProvdBase

	{

	/**

	* The host resolver.

	*

	* This is the representative of the application RHostResolver within

	* the TCPIP stack. This is created by the CProtocolRes::NewHostResolverL.

	*/

public:

	CHostResolver(CProtocolRes &aProtocol);

	~CHostResolver();

	void GetByName(TNameRecord &aName);

	void GetByAddress(TNameRecord &aName);

	void SetHostName(TDes& aNameBuf);

	void GetHostName(TDes& aNameBuf);

	void CancelCurrentOperation();

	TInt SetOption(TUint level, TUint aName,const TDesC8 &option);

	void Unlink();						//< Called by iSession, to remove the iSession link

	void Reply(const TDnsMessage &aReply, const TDesC8 &aPayload);	//< Called by iSession, when DND has replied.

	void QueryComplete(TInt aResult);	//< Called by iSession, when query completed ??

	void Query(const TDesC8& aQuery, TDes8& aResult, TInt aCount);

	TInt SecurityCheck(MProvdSecurityChecker *aChecker);

	TBool IsPending() { return iRequest.IsPending(); }

	void BuildMessage(TUint16 aId, TDes8 &aBuffer) const { iRequest.BuildMessage(aId, aBuffer); }

#ifdef SYMBIAN_DNS_PUNYCODE

	TBool IsIdnEnabled();

#endif //SYMBIAN_DNS_PUNYCODE

	CHostResolver *iNext;		//< Next resolver link chain

	CDndSession *iSession;		//< Assigned DND session or NULL, if none yet.

private:

	LOG(TInt Session() {return iSession ? (TInt)iSession->iSessionId : 0;})

	void Submit();

	CProtocolRes &iProtocol;	//< Link to the 'resolver' protocol instance

	TUint32 iNetworkId;			//< The default network ID.

	TUint32 iCurrentId;			//< The network ID for the current query

	TDnsRequest iRequest;		//< The query being served

	THostName iHostName;		//< The hostname (only used for SetHostName)

	TUint iNoNext:1;			//< if = 1, next should return Not Found

	TUint iHasNetworkServices:1;//< = 1, if client has network services.

#ifdef SYMBIAN_DNS_PUNYCODE

	TUint iEnableIdn:1;			// if =1 , Idn support is enabled.

#endif //SYMBIAN_DNS_PUNYCODE

	MProvdSecurityChecker *iSecurityChecker;

public:

	void NoDndAvailable();

	RTimeout iTimeout;

	};

//	CHostResolverLinkage

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

//	Glue to bind timeout callback from the timeout manager. Only used for

//	detecting a missing or misbehaving DND.

// 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 KHostResolverTimeoutOffset 584

__ASSERT_COMPILE(KHostResolverTimeoutOffset == _FOFF(CHostResolver, iTimeout));

#else

#define KHostResolverTimeoutOffset _FOFF(CHostResolver, iTimeout)

#endif

class CHostResolverLinkage : public TimeoutLinkage<CHostResolver, KHostResolverTimeoutOffset>

	{

public:

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

		{

		Object(aLink)->NoDndAvailable();

		}

	};

//

//	RES Class Implementation

// RES::Identify

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

void RES::Identify(TServerProtocolDesc &aEntry)

	{

	_LIT(KResolver, "resolver");

	aEntry.iName = KResolver;

	aEntry.iAddrFamily = KAfInet;

	aEntry.iSockType = KSockDatagram;

	aEntry.iProtocol = KProtocolInet6Res;

	aEntry.iVersion = TVersion(1, 0, 0);

	aEntry.iByteOrder = ELittleEndian;

	aEntry.iServiceInfo = KSIConnectionLess | KSIMessageBased | KSIRequiresOwnerInfo;

	aEntry.iNamingServices = 0;

	aEntry.iSecurity = KSocketNoSecurity;

	aEntry.iMessageSize = KSocketMessageSizeNoLimit;

	aEntry.iServiceTypeInfo = ESocketSupport;

	aEntry.iNumSockets = 1;	// Only 1 DND allowed.

	}

CProtocolBase *RES::NewL(CIfManager *const aInterfacer)

	{

	return new (ELeave) CProtocolRes(*aInterfacer);

	}

// Constructors for the TDnsRequest

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

TDnsRequest::TDnsRequest() :

	TDnsRequestBase(),

	iQuery(TPtrC8(0, 0)),

	iResponse(NULL)

	/**

	* Construct empty request = No Query Active

	*/

	{

	}

TDnsRequest::TDnsRequest(TNameRecord &aQuery, TInt aNext, TInt aType) :

	TDnsRequestBase(aType, aNext),

	iQuery(TPtrC8((TUint8 *)&aQuery, sizeof(aQuery))),

	iResponse((TUint8 *)&aQuery)

	/**

	* Construct a GetByName/GetByAddress request.

	*

	* @param aQuery	The query buffer in the SocketServer

	* @param aNext = 0 for the actual query, > 0 for additional results.

	* @param aType GetByName or GetByAddress.

	*/

	{

	}

TDnsRequest::TDnsRequest(const TDesC8 &aQuery, TDes8 &aResponse, TInt aNext) :

	TDnsRequestBase(KDnsRequestType_TDnsQuery, aNext),

	iQuery(aQuery),

	iResponse((TUint8 *)&aResponse)

	/**

	* Construct a special DNS query request.

	*

	* @param aQuery The query buffer in the SocketServer

	* @param aResponce The responece buffer in the SocketServer

	* @param aNext = 0 for the actual query, > 0 for additional results.

	*/

	{

	}

TDnsRequest::TDnsRequest(const THostName &aName, TDes &aResponse, TInt aType) :

	TDnsRequestBase(aType, 0),

	iQuery(TPtrC8((TUint8 *)&aName, sizeof(aName))),

	iResponse((TUint8 *)&aResponse)

	/**

	* Construct Get/Set HostName.

	*

	* @param aName The hostname (for SetHostName)

	* @param aResponce The responce buffer in the SocketServer

	* @param aType Set or get hostname.

	*/

	{

	}

void TDnsRequest::BuildMessage(TUint16 aId, TDes8 &aBuffer) const

	/**

	* Build the message from the request parameters.

	*/

	{

	aBuffer.SetLength(0);

	if (aBuffer.MaxLength() >= (TInt)sizeof(TDnsRequestBase) + iQuery.Length())

		{

		aBuffer = Header();

		((TDnsRequestBase *)aBuffer.Ptr())->iSession = aId;

		aBuffer.Append(iQuery);

		}

	else

		{

		// This means that DND is trying to read with too short buffer.

		LOG(Log::Printf(_L("\tres *** DND buffer is short ***")));

		}

	}

//

//	CProtocolRes Class Implementation

CProtocolRes::CProtocolRes(CIfManager &aInterfacer) : iInterfacer(aInterfacer)

	{

	LOG(Log::Printf(_L("new\tres resolver[%u] construct"), this));

	}

void CProtocolRes::BindL(CProtocolBase * /*aProtocol*/, TUint /*aId*/)

	/** Dummy. No real functionality. */

	{

	// Allow anyone to bind, and forget about it...

	}

void CProtocolRes::Unbind(CProtocolBase * /*aProtocol*/, TUint /*aId*/)

	/** Dummy. No real functionality. */

	{

	// Just pass any unbind too..

	}

// CProtocolRes::StartL

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

void CProtocolRes::StartL()

	{

	/**

	* Register for the event service.

	* Called after all binding is complete. Register for the event

	* service to receive configuration changes in the interfaces.

	*/

	MEventService &mgr = *IMPORT_API_L((&iInterfacer), MEventService);

	mgr.RegisterListener(this, EClassAddress);

	mgr.RegisterListener(this, EClassInterface);

	}

// CProtocolRes::Notify

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

void CProtocolRes::Notify(TUint aEventClass, TUint aEventType, const void *aData)

	/**

	* Configuration changed event.

	*

	* This is called by the event manager (MEventService) for the registered events.

	* Analyze the event and if the conditions are met, request a "configuration changed"

	* message to be sent to the DND.

	*

	* @param aEventClass The event class

	* @param aEventType The event type

	* @param aData The event infrormation (TInetAddressInfo or TInetInterfaceInfo)

	*/

	{

	if (!iConfigureDone)

		return;	// Configure request is already pending, nothing to do!

	if (aEventClass == EClassAddress)

		{

		// ...for now, all address events require reconfigure

		const TInetAddressInfo &ai = *(TInetAddressInfo *)aData;

		if ((ai.iFlags & TInetAddressInfo::EF_Id) == 0)

			return;	// Only interested in addresses, not prefixes.

		if (aEventType != EventTypeDelete && (ai.iState != TInetAddressInfo::EAssigned))

			return;	// Only interested in valid or deleted addresses.

#ifdef _LOG

		TInetAddr addr(ai.iAddress, 0);

		TBuf<70> tmp;

		addr.Output(tmp);

		Log::Printf(_L("<>\tres Address Event(%d) IF %d [%S]"),  aEventType, ai.iInterface, &tmp);

#endif

		}

	else if (aEventClass == EClassInterface)

		{

		// ...for now all interface events require reconfigure

#ifdef _LOG

		const TInetInterfaceInfo &ii = *(TInetInterfaceInfo *)aData;

		Log::Printf(_L("<>\tres Interface Event(%d) IF %d [%S]"), aEventType, ii.iIndex, &ii.iName);

#endif

		}

	else

		return;

	//

	// An event that requires DND reconfiguration has occurred.

	//

	iConfigureDone = 0;

	if (iDND)

		iDND->Activate();

	}

// CProtocolRes::NewSAPL

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

CServProviderBase* CProtocolRes::NewSAPL(TUint /*aSockType*/)

	/**

	* Create a new DNS SAP.

	* This SAP should be the DND server offering the

	* name resolution services through this datagram

	* socket.

	*

	* Only ONE DND server at any time can be active. Multiple

	* SAP creations are rejected.

	*/

	{

	LOG(Log::Printf(_L("NewSAPL\tres resolver[%u]"), this));

	if (iDND)

		User::Leave(KErrAlreadyExists); // Only one DND is allowed (should not get here)

	iDND = new (ELeave) CProviderRes(*this);

	LOG(Log::Printf(_L("\tres DND[%u] new"), iDND));

	return iDND;

	}

// CProtocolRes::NewHostResolverL

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

CHostResolvProvdBase *CProtocolRes::NewHostResolverL()

	/**

	* Create a resolver object.

	*

	* Create the internal object match the client RHostResolver. These

	* objects are stored in the linked list (iQueries) at CProtocolRes.

	*

	* @return The host resolver

	*/

	{

	CHostResolver *hr = new (ELeave) CHostResolver(*this);

	hr->iNext = iQueries;

	iQueries = hr;

	return hr;

	}

// CProtocolRes::NewServiceResolverL

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

CServiceResolvProvdBase *CProtocolRes::NewServiceResolverL()

	/**