// 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_sock.h - Resolver socket API

// This API defines structures and constants which are used

// between the TCP/IP stack and an external DNS resolver

// daemon.

//

#ifndef __RES_SOCK_H__

#define __RES_SOCK_H__

/**

@file res_sock.h

The resolver socket message format

@internalComponent	Domain Name Resolver

*/

#include <e32def.h>

#include <dns_qry.h>

/**

* DND Socket option to specify the max sessions.

*

* The DND needs to tell the gateway code how many

* parallel RHostResolvers (sessions) it can handle.

* This is done by setting this socket option.

*/

const TUint KSolDnd			= 0x10000882;	// Use DND UID value as a level.

const TUint KSoDndSessions	= 1;			// Only SetOption, and parameter is "int" (= number of sessions)

const TInt KDnsRequestType_GetByName = 0;	//< Query is GetByName

const TInt KDnsRequestType_GetByAddress = 1;//< Query is GetByAddress

const TInt KDnsRequestType_TDnsQuery = 2;	//< Query is special DNS query

const TInt KDnsRequestType_GetHostName = 3;	//< Query current hostname (blocks until unique if LLMNR)

const TInt KDnsRequestType_SetHostName = 4;	//< Set new hostname (start unique checking if LLMNR)

const TInt KDnsRequestType_Configure = 5;	//< Interface state in stack has changed.

class TDnsRequestBase

/**

  The resolver socket message format

  The communication between the resolver gateway code in the stack and

  the resolver implementation occurs over a datagram socket. The

  queries and replies are passed as datagrams. Each datagram contains

  a binary message (TDnsMessage) with three fixed 32 bit header fields

  and a payload.

  In query the fixed fields are defined as follows:

@li

  (1) the payload type (TNameRecord, TDnsQuery or THostName)

@li

  (2) the "next indicator" (0 is for new query, non-zero requests next

  answer for earlier query).

@li

  (3) the network id. The value ZERO indicates unknown; in such case

  the resolver only looks name from local host file, and if not found,

  a KErrCompletion error is returned. This error is special, and requests

  the Socket Server to assign a non-zero network id and repeat the query.

@li

  followed by the query payload, as defined by the first header field.

  The payload is TNameRecord, if the query was GetByName or GetByAddress.

  TDnsQuery payload defines the query explicitly.

  Any message shorter than the required minimum length is

  interpreted by the resolver as <b>cancel request</b>. Such message

  will stop all currently occurring activity associated with this session,

  and disconnect the resolver from the socket. This

  is part of the protocol and is also used by the resolver gateway

  code, when application cancels the request (it puts a zero length

  message into the socket).

  In a reply message, the same header format is used, but the fields have

  partially different interpretation:

@li

  (1) the payload type (TNameRecord, TDnsQryRespBase derived object,

  THostName).

  The value of the field is the same as in the originating query message,

  except for GetHostName.

@li

  (2) the result code of the query (KErrNone or some error indication)

@li

  (3) the network id (same as in query)

@li

   followed by the response payload, as defined by the first header field.

   The payload is returned to the client application as a reply to the query.

*/

	{

public:

	TDnsRequestBase() {}

	TDnsRequestBase(TInt aType, TInt aNext) : iType((TUint8)aType), iNext(aNext) {}

	inline const TInt HeaderSize() const

		{

		return (TInt)sizeof(*this);

		}

	inline TPtrC8 Header() const

		{

		return TPtrC8((TUint8 *)this, HeaderSize());

		}

	TUint8 iType;		//< Type of the payload: TDnsQuery/TDnsQryResp or TNameRecord

	TUint8 iScope;		//< The scope level of the Address Domain Id [0..15]

#ifdef SYMBIAN_DNS_PUNYCODE

				//< The MSB 4 bits are used to indicate whether the IDN support is enabled / disabled

#endif //SYMBIAN_DNS_PUNYCODE

	TUint16 iSession;	//< The session ID.

	TInt iNext;			//< Next indicator: 0, 1, 2, ... (query), or the result (on reply)

	TUint32 iId;		//< Address domain Id

	};

// Need write access to members, and just for this, need to derive all

// responce classes... (yuk!)

//

class TDndRespA : public TDnsRespA

	{

public:

	inline TDndRespA() : TDnsRespA() {} 

	inline TInetAddr&  HostAddress() { return iInetAddr; }

	};

class TDndRespAAAA : public TDnsRespAAAA

	{

public:

	inline TDndRespAAAA() : TDnsRespAAAA() {}

	inline TInetAddr&  HostAddress() { return iInetAddr; }

	};

class TDndRespPTR : public TDnsRespPTR

	{

public:

	inline TDndRespPTR() : TDnsRespPTR() {}

	inline TDes8& HostName() { return iName; }

	};

class TDndRespMX : public TDnsRespMX

	{

public:

	inline TDndRespMX() : TDnsRespMX() {}

	inline TDes8 &HostName() { return iHostName; }

	};

class TDndRespSRV : public TDnsRespSRV

	{

public:

	inline TDndRespSRV() : TDnsRespSRV() {}

	inline TDes8 &Target() { return iTarget; }

	};

class TDndReply : public TDnsQryRespBase

	{

public:

	inline TDndReply(TUint16 aRRespType, TUint16 aRRClass) : TDnsQryRespBase(aRRespType, aRRClass) {}

	};

class TDndRespNAPTR : public TDnsRespNAPTR

	{

public:

	inline TDndRespNAPTR() : TDnsRespNAPTR() {}

	inline TDes8 &Replacement() { return iReplacement; }

	};

class TDnsMessage : public TDnsRequestBase

	{

public:

	inline TPtrC8 Payload(const TInt aSize) const

		{

		const TInt N = aSize < HeaderSize() ? 0 : aSize - HeaderSize();

		return TPtrC8((TUint8 *)this + HeaderSize(),  N);

		}

	inline TPtr8 Payload(const TInt aSize)

		{

		const TInt N = aSize < HeaderSize() ? 0 : aSize - HeaderSize();

		return TPtr8((TUint8 *)this + HeaderSize(),  N, N);

		}

private:

	// This union is here to make the size of this

	// class large enough for the largest of the

	// reply or query variants. (must use TUint8

	// arrays, because the classes themselves cannot

	// be used in union due to contructor problems).

	union

		{

		TUint8 iNameRecord[sizeof(TNameRecord)];		//< GetByName/GetByAddress query/reply

		TUint8 iDnsQuery[sizeof(TDnsQuery)];			//< Special Query

		TUint8 iDnsRespSRV[sizeof(TDnsRespSRV)];		//< SRV reply

		TUint8 iDnsRespA[sizeof(TDnsRespA)];			//< A reply

		TUint8 iDnsRespAAAA[sizeof(TDnsRespAAAA)];		//< AAAA reply

		TUint8 iDnsRespPTR[sizeof(TDnsRespPTR)];		//< PTR reply

		TUint8 iDnsRespNAPTR[sizeof(TDnsRespNAPTR)];	//< NAPTR reply

		TUint8 iDnsRespMX[sizeof(TDnsRespMX)];			//< MX reply

		TUint8 iHostName[sizeof(THostName)];			//< SetHostName/GetHostName

		} iPayload;

public:

	// Access to the query structures

	// GetByName/GetByAddress query/reply

	inline TNameRecord &NameRecord() const

		{ return (TNameRecord &)iPayload; }

	// Special Query

	inline TDnsQuery &Query() const

		{ return (TDnsQuery &)iPayload; }

	// Set/Get HostName

	inline THostName &HostName() const

		{ return (THostName &)iPayload; }

	// Access the the Reply structures

	// Generic Response header

	inline TDndReply &Reply() const	{ return (TDndReply &)iPayload; }

	// SRV reply

	inline TDndRespSRV &SRV() const { return (TDndRespSRV &)iPayload; }

	// A reply

	inline TDndRespA &A() const	{ return (TDndRespA &)iPayload; }

	// AAAA reply

	inline TDndRespAAAA &AAAA() const { return (TDndRespAAAA &)iPayload; }

	// PTR reply

	inline TDndRespPTR &PTR() const	{ return (TDndRespPTR &)iPayload; }

	// NAPTR reply

	inline TDndRespNAPTR &NAPTR() const	{ return (TDndRespNAPTR &)iPayload; }

	// MX reply

	inline TDndRespMX &MX() const { return (TDndRespMX &)iPayload; }

	};

typedef TPckgBuf<TDnsMessage> TDnsMessageBuf;

#endif