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

// message.cpp - name resolver DNS message interpreter

//

#include <dns_qry.h>

#include "res_sock.h"

#include "message.h"

#include <networking/dnd_err.h>

#include "dns_ext.h"

#ifdef EXCLUDE_SYMBIAN_DNS_PUNYCODE

#undef SYMBIAN_DNS_PUNYCODE

#endif //EXCLUDE_SYMBIAN_DNS_PUNYCODE

// Constants

_LIT8(KIPv4AddrToHost, ".in-addr.arpa");

#ifdef DNS_REVERSE_IP6_INT

_LIT8(KIPv6AddrToHost, ".ip6.int");

#else

_LIT8(KIPv6AddrToHost, ".ip6.arpa");

#endif

#ifdef SYMBIAN_DNS_PUNYCODE 

/* This macro is to check whether the character passed is of UTF encoded */

#define ISUTF16(x) ((x>= 0xD800 && x<= 0xDFFF)? ETrue : EFalse)

#endif //SYMBIAN_DNS_PUNYCODE

//

// DnsCompareNames

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

// A global utility function

//

/**

// The DNS domain names have a special case folding rules. The names

// are BINARY data (can include anything in range [0..255], but when

// comparing two names, ASCII lower and and upper case letters should

// compare equal, e.g  A-Z == a-z.

//

// @param	aName1	to be compared

// @param	aName2	to be compared

// @returns	TRUE, if names are equal under DNS case folding rules

*/

TBool DnsCompareNames(const TDesC8 &aName1, const TDesC8 &aName2)

	{

	static const TUint8 KAscii_A = 0x41;

	static const TUint8 KAscii_Z = 0x5a;

	static const TUint8 KAscii_lower = 0x20;

	TInt n = aName1.Length();

	if (n != aName2.Length())

		return 0;	// not same, lengths differ

	//

	// Need to do the special "DNS case insensitive" compare

	//

	const TUint8 *const p = aName1.Ptr();

	const TUint8 *const q = aName2.Ptr();

	while (--n >= 0)

		{

		TUint8 x = p[n];

		TUint8 y = q[n];

		if (x != y)

			{

			if (x >= KAscii_A && x <= KAscii_Z)

				x += KAscii_lower;

			if (y >= KAscii_A && y <= KAscii_Z)

				y += KAscii_lower;

			if (x != y)

				return 0;

			}

		}

	return 1;

	}

//

// Initialize TDndHeader

//

void TDndHeader::Init(const TUint16 aID, const TUint8 aOpcode)

	{

	// Set ID to aID

	i[0] = (TUint8)(aID / 0x0100);

	i[1] = (TUint8)(aID % 0x0100);

	// Set QR = 0; Opcode = aOpcode; AA = 0; TC = 0; RD = 1

	i[2] = 1;

	i[2] |= (aOpcode << 3);

	// Set RA = 0; Z = 0; RCode = 0

	i[3] = 0;

	// Set QDCOUNT = 1

	i[4] = 0;

	i[5] = 1;

	// Set all other counts as zero.

	// ANCOUNT = 0;

	// NSCOUNT = 0;

	// ARCOUNT = 0;

	i[6] = 0;

	i[7] = 0;

	i[8] = 0;

	i[9] = 0;

	i[10] = 0;

	i[11] = 0;

	}

// to set the ID field of header

void TDndHeader::SetId(const TUint16 aID)

	{

	i[0] = (TUint8)(aID / 0x0100);

	i[1] = (TUint8)(aID % 0x0100);

	}

#ifdef LLMNR_ENABLED

// TDndHeader::SetQR() - To set the query/response bit of the header

void TDndHeader::SetQR(const TUint aQR)

    {

    i[2] |= ((aQR & 0x1) << 7);

    }

#endif

// TDndHeader::SetOpcode() - To set the opcode field of the header

void TDndHeader::SetOpcode(const TUint8 aOpcode)

	{

	i[2] |= ((aOpcode & 0xF) << 3);

	}

#ifdef LLMNR_ENABLED

// TDndHeader::SetAA() - To set the authoritative answer bit of the header

void TDndHeader::SetAA(const TUint aAA)

    {

    i[2] |= ((aAA & 0x1) << 2);

    }

// TDndHeader::SetRCode() - To set the value of RCode field of the header

void TDndHeader::SetRCode(const TUint aRCode)

    {

    i[3] |= aRCode & 0xF;

    }

#endif

// TDndHeader::SetQdCount() - To set the QdCount field

void TDndHeader::SetQdCount(const TUint16 aQdCount)

	{

	i[4] = (TUint8)(aQdCount / 0x0100);

	i[5] = (TUint8)(aQdCount % 0x0100);

	}

// TDndHeader::SetAnCount() - To set the answer count field

void TDndHeader::SetAnCount(const TUint16 aAnCount)

	{

	i[6] = (TUint8)(aAnCount / 0x0100);

	i[7] = (TUint8)(aAnCount % 0x0100);

	}

void TDndHeader::SetArCount(const TUint16 aArCount)

	{

	i[10] = (TUint8)(aArCount / 0x0100);

	i[11] = (TUint8)(aArCount % 0x0100);

	}

#ifdef SYMBIAN_DNS_PROXY

void TDndHeader::SetNsCount(const TUint16 aNsCount)

	{

	i[8] = (TUint8)(aNsCount / 0x0100);

	i[9] = (TUint8)(aNsCount % 0x0100);

	}

#endif

// TMsgBuf::VerifyMessage

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

/**

// Verify basic header fields in the responce.

//

// @retval aRCode The RCode from the message (if return > 0)

// @retval aQuestion The question from the message (if return > 0)

//

// @return

//	@li < 0, if there are any format errors with the message

//	@li > 0, offset to the first answer RR after the question section

*/

TInt TMsgBuf::VerifyMessage(TInt &aRCode, TDndQuestion &aQuestion) const

	{

	// Check that message is actually long enough for the header

	// Return length of the fixed header (= offset pointing to next part)

	ASSERT(sizeof(TDndHeader) == KDnsMinHeader);

	if (Length() < TInt(sizeof(TDndHeader)))

		return KErrDndDiscard;

	const TDndHeader &hdr = Header();

	// ..do some simple insanity tests, and discard if odd things

	// detected.

	if (hdr.ANCOUNT() < 0)

		return KErrDndDiscard;

	if (hdr.NSCOUNT() < 0)

		return KErrDndDiscard;

	if (hdr.ARCOUNT() < 0)

		return KErrDndDiscard;

	TInt offset = aQuestion.Create(*this, sizeof(TDndHeader));

	if (offset > 0)

		{

		// Question extracted, now we can look for EDNS0 OPT record

		// to find the real RCODE...

		TDndRR opt_rr(*this);

		const TInt start = hdr.ANCOUNT() + hdr.NSCOUNT();

		if (opt_rr.LocateRR(offset, start + hdr.ARCOUNT(), EDnsQType_OPT, EDnsQClass_ANY, start) > offset)

			{

			// OPT RR has been located

			// ..return extend RCODE.

			aRCode = ((opt_rr.iTTL >> 20) & 0xFF0) | hdr.RCODE();

			}

		else

			{

			// NO OPT RR present, RCODE is as it

			aRCode = hdr.RCODE();

			}

		}

	return offset;

	}

// TMsgBuf::GetNextName

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

/**

// @param	aOffset	from the start of the message to the domain name

// @retval	aName	receives the extracted domain name (in raw DNS 8bit encoding)

// @param	aDepth	("internal" paramater) recursion count to catch looped compression

// @returns

//	@li > 0, updated offset pointing past the name portion

//	@li	< 0, an error was detected

*/

TInt TMsgBuf::GetNextName(TInt aOffset, TDes8 &aName, const TUint aDepth) const

	{

	TInt tag;

	TInt err;

	if (aDepth >= KDndMaxLoopCount ||	// Prevent infinite recursion...

		aOffset >= Length() ||			// ...offsets beyond the buffer end,

		aOffset < 0)					// ...or before buffer start (someone didn't check error return!)

		return KErrDndDiscard;

	const TUint8 *p = Ptr() + aOffset;

	while ((tag = *p) != 0)

		{

		if ((tag & 0xC0) == 0xC0)

			{

			if (Length() < aOffset + 2)

				return KErrDndDiscard;

			const TInt tempOffset = (tag - 0xC0) * 256 + *(p+1);

			err = GetNextName(tempOffset, aName, aDepth+1);

			if (err < KErrNone)

				return err;

			p += 2;

			aOffset += 2;

			break;

			}

		else

			{

			p++;

			aOffset++;

			if (aName.Length() + tag >= aName.MaxLength())

				return KErrDndNameTooBig;

			if (Length() < aOffset + tag)

				return KErrDndUnknown;

			aName.Append(TPtrC8(p, tag));

			aName.Append('.');

			p += tag;

			aOffset += tag;

			}

		}

	if (tag == 0)

		{

		p++;

		aOffset++;

		// if there is a 'dot' at the end, get rid of it

		if (aName.Length() != 0)

			aName.Delete(aName.Length() - 1, 1);

		}

	return aOffset;

	}

// TMsgBuf::GetNextString

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

/**

// @param	aOffset	from the start of the message to the character string

// @retval	aString	receives the extracted string (in raw DNS 8bit encoding). This

//			is only a reference to the original DNS message buffer, which must be

//			kept around while this is used.

// @returns

//	@li	> 0, updated offset pointing past extracted string

//	@li	< 0, an error was detected

*/

TInt TMsgBuf::GetNextString(TInt aOffset, TPtrC8 &aString) const

	{

	if (aOffset >= Length())

		return KErrDndUnknown;	// corrupt data

	const TUint8 *p = Ptr() + aOffset;

	//

	// Extract <character-string> length

	//

	TInt length = *p++;

	aOffset += length + 1;

	if (aOffset > Length())

		return KErrDndUnknown;	// corrupt data

	aString.Set(p, length);

	return aOffset;

	}

// TMsgBuf::GetName

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

/**

// @param	aOffset	from the start of the message to the start of domain name

#ifdef SYMBIAN_DNS_PUNYCODE

// @param   aIdnEnabled   

#endif

// @retval	aName	the extracted domain name (system dependent encoding)

// @returns

//	@li	> 0, offset updated pointing past the name portion

//	@li	< 0, an error was detected

*/

#ifdef SYMBIAN_DNS_PUNYCODE

TInt TMsgBuf::GetName(TInt aOffset, TDes &aName,TBool aIdnEnabled) const

#else

TInt TMsgBuf::GetName(TInt aOffset, TDes &aName) const

#endif //SYMBIAN_DNS_PUNYCODE

	{

	// Use TDndName as temporary buffer. This seemingly

	// unnecessary juggling is present because of the potentially

	// hairy/complex issues of DNS <-> UNICODE translation. The idea

	// is to have one clean location which implements it:

	// TDndName::SetName and TDndName::GetName methods.

	TDndName tmp;

#ifdef SYMBIAN_DNS_PUNYCODE

	tmp.EnableIdn(aIdnEnabled);

#endif

	TInt i = tmp.SetName(*this, aOffset);

	if (i < 0)

		return i;

	TInt err = tmp.GetName(aName);

	// This function must return offset when no errors

	return err == KErrNone ? i : err;

	}

// TMsgBuf::AppendName

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

/**

// @param	aName

//		domain name to be appended

// @param	aCompressed

//	@li	= 0,

//		the name is assumed to be complete name will be terminated with "root label"

//	@li	> 0,

//		the name is assumed to be a prefix to another name already stored into the

//		message starting at indicated offset.

//		The name (prefix) is terminated with a "compression ptr".

//		The value must be in range [1..Length()-1].

//

// @returns

//	@li	KErrNone

//		if name appended succesfully

//	@li	KErrDndNameTooBig,

//		if name does not fit the message buffer

//	@li	KErrBadName,

//		if name is invalid, e.g. has empty or too long (> 63)

//		components

//	@li	KErrDndUnknown

//		if aCompressed is illegal, e.g. not in range [0..Length()-1]

*/

TInt TMsgBuf::AppendName(const TDesC8 &aName, const TUint aCompressed)

	{

	if (aCompressed >= (TUint)Length())

		return KErrDndUnknown; // Don't allow forward references in compression pointers.

	// The space requirement

	// + length of the iName

	// and

	//    + 1 (for the terminator NUL byte, root)

	//  or

	//    + 2 (for the compression pointer)

	//	

	// [note: if the name already has a trailing '.', the code below

	// will handle it, but the spacerequirement computation is too

	// large by one byte -- a minor discrepancy, which is

	// not worth coding -- msa]

	if (Length() + aName.Length() + 1 + (aCompressed > 0) > MaxLength())

		return KErrDndNameTooBig;

	//

	// Append <domain-name> as labels

	//

	TInt i;

	TPtrC8 name(aName);

	while ((i = name.Locate('.')) != KErrNotFound)

		{

		// a valid label contains at least one and at most 63 characters

		if (i < 1 || i > 63)

			return KErrDndBadName;	// ..abort message build!

		Append((TChar)i);

		Append(name.Left(i));

		name.Set(name.Mid(i+1));		// Skip the dot.

		}

	i = name.Length();

	if (i > 0)

		{

		// append the last component...

		if (i > 63)

			return KErrDndBadName;

		Append((TChar)i);

		Append(name);

		}

	//

	// Append terminator

	//

	if (!aCompressed)

		Append((TChar)0);		//Root

	else

		{

		Append((TChar)((aCompressed / 0x100) | 0xC0));

		Append((TChar)(aCompressed % 0x100));

		}

	return KErrNone;

	}

// TMsgBuf::GetRR

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

/**

// @param aOffset	of the recource record (points to NAME)

// @retval aType	RR type

// @retval aClass	RR class

// @retval aTTL		RR TTL (time to live)

// @retval aRD		offset to the beginning of the RDATA

// @retval aRDLength	the length of the RDATA

//	

// @return	offset pointing after the RR.

*/

TInt TMsgBuf::GetRR(const TInt aOffset, TUint16 &aType, TUint16 &aClass, TUint32 &aTTL, TUint &aRd, TUint &aRdLength) const

	{

	return Header().Resource(aOffset, Length(), aType, aClass, aTTL, aRd, aRdLength);

	}

TInt TMsgBuf::SkipName(TInt aOffset) const

	{

	return Header().NameSkip(aOffset, Length());

	}

// TDndName::SetName

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

// Set PTR name from address

//

/**

// Translate the address into a query name for the PTR query.

// For example 172.21.33.80 -> 80.33.21.172.in-addr.arpa.

//

// @param	aAddr	the address to be translated into PTR name

// @returns

//	@li		KErrnone, if translation succeeded

//	@li		KErrNotSupported, if translation not supported

//			(bad address or unknown address family)

*/

TInt TDndName::SetName(const TInetAddr &aAddr)

	{

	if (aAddr.Family() == KAfInet ||

		aAddr.IsV4Mapped() ||	// V4 Mapped is internal, and always means IPv4

		aAddr.IsV4Compat())		// Treating V4 Compatible as IPv4 might be questionable?

		{

		TUint32 address = aAddr.Address();

		if (address == KInetAddrNone)

			return KErrNotSupported;

		Format(_L8("%d.%d.%d.%d"),

			(TUint8)(address),

			(TUint8)(address >> 8),

			(TUint8)(address >> 16),

			(TUint8)(address >> 24));

		Append(KIPv4AddrToHost);

		return KErrNone;

		}

	else if (aAddr.Family() == KAfInet6)	// for IPv6

		{

		SetLength(0);

		const TIp6Addr &address = aAddr.Ip6Address();

		// ..are there any addresses that should never be

		// PTR queried? unspecified? loopback? anything else?

		// Or, should even these tests removed and let the

		// query just fail normally? -- msa

		if (address.IsUnspecified() ||

			address.IsLoopback())

			return KErrNotSupported;

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

			{

			for (TInt j = 0; j < 2; j++)

				{

				TChar c;

				TUint8 digit = (TUint8)((address.u.iAddr8[i] >> (4 * j)) & 0x0f);

				if (digit < 10)

					c = (TChar)('0' + digit);

				else

					c = (TChar)('a' + digit - 10);

				Append(c);

				if (i != 0 || j != 1)