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

// engine.cpp - nslookup client engine

//

#include <e32math.h>

#include <e32std.h>

#include <eikenv.h>

#include <plpsess.h>	//Used for RRemoteLink

#include <networking/dnd_err.h>

#include <dns_ext.h>

#include <dns_qry.h>

#include "engine.h"

#include <nslookup.rsg>

#include "nslookup.h"

CNslookup::CNslookup(): CActive(EPriorityStandard)

	{

	CActiveScheduler::Add(this);	//Adds itself to the scheduler only the first time

	}

//Sets the remote link to off

void CNslookup::DisableRemoteLink()

	{

	RRemoteLink link;

	TRemoteLinkStatus state;

	TInt err=link.Open();

	if (err==KErrNone)

		{

		if (link.Status(state)!=KErrNone)

			return;

		if (state.iStatus!=TRemoteLinkStatus::EDisabled)

			{

			iConsole->WriteLine(_L("Disabling Remote link\n"));

			link.Disable(); 

			}

		link.Close();

		}

	}

//Sets all default values. Actually it's no more a L function

void CNslookup::ConstructL(const TPreferences& aPref)

	{

	// Base class second-phase construction.

	iHostname=aPref.iHostname;

	}

//return the current preferences

void CNslookup::GetPreferences(TPreferences &aPref) const

	{	

	aPref.iHostname=iHostname;		//Address to Ping

	}

void CNslookup::DefaultPreferences(TPreferences &aPref)

	{	

	aPref.iHostname=_L("127.0.0.1");

	}

const TDesC* CNslookup::GetHostName() const

	{

	return &iHostname;

	}

void CNslookup::SetHostName(const TDes& aHostname)

	{

	iHostname = aHostname;

	}

void CNslookup::SetConsole(CNslookupContainer* aConsole)

	{

	iConsole = aConsole;

	}

CNslookup::~CNslookup()

	{

	Cancel();

	}

//Shows the error and set the application as not running. 

//Requires a return after calling it!

void CNslookup::Error(const TDesC& string,TInt error)

	{

	TBuf<150> aux;

	TBuf<100> errtxt;

	CEikonEnv::Static()->GetErrorText( errtxt,error);

	aux.Append(string);	

	aux.Append(_L(": "));

	aux.Append(errtxt);

	aux.AppendFormat(_L(" (%d)\n"), error);

	iConsole->WriteLine(aux);

	}

void CNslookup::Stop()

	{

	iHostResolv.Close();

	iSockServ.Close();

	CEikonEnv::Static()->BusyMsgCancel();

	}

void CNslookup::BeginL()

	{

	TInt err=0;

	if (IsRunning())	// There's another instance running

		return;

	//INITIALIZATION

	DisableRemoteLink();

	iConsole->WriteHostL(iHostname);

	//connecting the Socket Server

	err = iSockServ.Connect();	//KESockDefaultMessageSlots

	if (err!=KErrNone)

		{

		Error(_L("Socket Server Error (Connect)"),err);

		return;

		}

	err = iHostResolv.Open(iSockServ, KAfInet, KProtocolInetUdp);	// Address Resolver 

	if (err != KErrNone)

		{

		Error(_L("Resolver Error (Open)"),err);

		iSockServ.Close();

		return;

		}

	iConsole->WriteLine(_L("\nResolving...\n"));	

	CEikonEnv::Static()->BusyMsgL(R_RESOLVING_NAME);

	TUint16 querytype = KDnsRRTypeInvalid;

	// This lengthy code checks what the user selected as query type in UI dialog

	switch (iQueryType)

		{

	case 0:		// Default (GetName)

		break;

	case 1:		// Query A

		querytype = KDnsRRTypeA;

		break;

	case 2:		// Query NS

		querytype = KDnsRRTypeNS;

		break;

	case 3:		// Query CNAME

		querytype = KDnsRRTypeCNAME;

		break;

	case 4:		// Query WKS

		querytype = KDnsRRTypeWKS;

		break;

	case 5:		// Query PTR

		querytype = KDnsRRTypePTR;

		break;

	case 6:		// Query HINFO

		querytype = KDnsRRTypeHINFO;

		break;

	case 7:		// Query MX

		querytype = KDnsRRTypeMX;

		break;

	case 8:		// Query TXT

		querytype = KDnsRRTypeTXT;

		break;

	case 9:		// Query AAAA

		querytype = KDnsRRTypeAAAA;

		break;

	case 10:	// Query SRV

		querytype = KDnsRRTypeSRV;

		break;

	case 11:	// Query NAPTR

		querytype = KDnsRRTypeNAPTR;

		break;

	case 12:	// Query Any

		querytype = KDnsQTypeANY;

		break;

#ifdef DND_DCM_EXTENSION				

	case 13:	// Cache Clear

		querytype = KDnsQTypeCacheClear;

		break;

#endif

	default:

		break;

		}

	// If query type was something else than default using GetName(), use the new

	// Query() interface instead

	if (querytype != KDnsRRTypeInvalid)

		{

#ifdef __RHOSTRESOLV_QUERY_IF

		TBuf8<KHostNameLimit> name8;

		name8.Copy(iHostname);

		TDnsQuery query(name8, querytype);

		TPckgC<TDnsQuery> querybuf(query);	

		// Hmm... Esock seems to use the current length when allocating a buffer for result

		// output. It should use MaxLength() instead, and now we have to do this to get

		// over with it

		iResult.SetLength(iResult.MaxLength());

		iHostResolv.Query(querybuf, iResult, iStatus);

#else

		TBuf<80> aux;

		aux.Copy(_L("Query() interface not supported\n"));

		iConsole->WriteLine(aux);

		iQueryType = 0;

		Stop();

		return;

#endif

		}

	else

		{

		if (iAddress.Input(iHostname) == KErrNone)

			{

			iHostResolv.GetByAddress(iAddress, iEntry, iStatus);

			}

		else

			{

			iHostResolv.GetByName(iHostname, iEntry, iStatus);

			}

		}

	iCount = 0;

	SetActive();	//Sets the object as Active.

	}

static TPtrC ErrorTextL(const TInt aCode)

	{

	switch (aCode)

		{

		case KErrNotFound:			return _L("Name not found");

//		case KErrDndTimedOut:		return _L("timed out");

//		case KErrDndNoHost:			return _L("no host");	// [dubious error code -- eliminate? ]

//		case KErrDndNoMemorySend:	return _L("Out of memory on send");

//		case KErrDndNotSent:		return _L("Query not sent");

		case KErrDndCache:			return _L("Cache error");

		case KErrDndFormat:			return _L("Bad DNS reply format");

		case KErrDndServerFailure:	return _L("DNS server failed");

		case KErrDndBadName:		return _L("Name does not exist in DNS");

		case KErrDndNotImplemented:	return _L("Query not implemented by DNS server");

		case KErrDndRefused:		return _L("DNS Server refused query");

//		case KErrDndNoMemoryProc:	return _L("Insufficient memory - can not process the response");

		case KErrDndNoRecord:		return _L("No record found of the desired type and class"); 

		case KErrDndNameTooBig:		return _L("Buffer overflow");

		case KErrDndUnknown:		return _L("Error in DND");

		case KErrDndServerUnusable:	return _L("No answer available from current server");

		default:

			break;

		}

	User::Leave(aCode);

	// NOTREACHED

	return _L("");  // to make compiler happy

	}

void CNslookup::RunL()

	{

	TInt src_addr = 0;

	TBuf<100> textIPaddress;	//text address to be displayed

	TBuf<356> aux;

	if (iStatus != KErrNone)

		{

		if (iCount == 0)

			{

			// An error message is only shown, if the primary query

			// failes, and not for subsequent Next() operations.

			TBuf<100> msg(iHostname);

			TRAPD(err,

				TPtrC errText = ErrorTextL(iStatus.Int());

				msg.AppendFormat(_L(" - %S\n"), &errText));

			if (err == KErrNone)

				iConsole->WriteLine(msg);

			else

				Error(msg, iStatus.Int());

			}

		Stop();

		return;

		}	

	// Check if we are using the query interface instead of GetName()

	if (iQueryType != KDnsRRTypeInvalid)

		{

#ifdef __RHOSTRESOLV_QUERY_IF

		QueryResponse();

		// See explanation of this SetLength() hack above

		iResult.SetLength(iResult.MaxLength());

		iHostResolv.QueryGetNext(iResult, iStatus);

		iCount++;

		SetActive();

#endif		

		return;

		}

	aux.Append(iEntry().iName);   // maybe the main name is not the entered

	switch (iEntry().iAddr.Family())

		{

	case KAfInet:

	case KAfInet6:

		aux.Append(_L(" is "));

		iHostAddr = TInetAddr::Cast(iEntry().iAddr);	//host address

		iHostAddr.Output(textIPaddress);

		aux.Append(textIPaddress);

		src_addr = iShowSource && !iHostAddr.IsUnspecified();

		break;

	case KAfDns:

		{

		SDnsRR &rr = TInetDnsRR::Cast(iEntry().iAddr).RR();

		if (rr.iClass == 1 /* IN */)

			{

			if (rr.iType == 2 /* NS */)

				{

				aux.Append(_L(" NS"));

				break;

				}

			else if (rr.iType == 6 /* SOA */)

				{

				aux.AppendFormat(_L(" SOA serial=%u refresh=%u retry=%u expire=%u min=%u"),

					(TUint)rr.iSOA.iSerial,

					(TUint)rr.iSOA.iRefresh,

					(TUint)rr.iSOA.iRetry,

					(TUint)rr.iSOA.iExpire,

					(TUint)rr.iSOA.iMinimum);

				break;

				}

			else if (rr.iType == 15 /* MX */)

				{

				aux.AppendFormat(_L(" MX preference=%d"), (TInt)rr.iMX.iPreference);

				break;

				}

			else if (rr.iType == 33 /* SRV */)

				{

				aux.AppendFormat(_L(" SRV port=%d priority=%d weight=%d"),

					(TInt)iEntry().iAddr.Port(), (TInt)rr.iSRV.iPriority, (TInt)rr.iSRV.iWeight);

				break;

				}

			else if (rr.iType == 35 /* NAPTR */)

				{

				TPtrC replacement = rr.iNAPTR.REPLACEMENT(iEntry().iName);

				TPtrC services = rr.iNAPTR.SERVICES(iEntry().iName);

				TPtrC regexp = rr.iNAPTR.REGEXP(iEntry().iName);

				aux.AppendFormat(_L(" NAPTR order=%d, preference=%d repl=%S services=%S regexp=%S"),

					(TInt)rr.iNAPTR.iOrder,

					(TInt)rr.iNAPTR.iPreference,

					&replacement,

					&services,

					&regexp);

				break;

				}

			}

		aux.AppendFormat(_L(" class=%d type=%d"), (TInt)rr.iClass, (TInt)rr.iType);

		}

		break;

	default:

		break;

		}

	const TUint flags = iEntry().iFlags;

	if (flags)

		{

		aux.Append(_L(" ( "));

		if (flags & EDnsAlias)

			aux.Append(_L("Alias "));

		if (flags & EDnsAuthoritive)

			aux.Append(_L("Authoritative "));

		if (flags & EDnsHostsFile)

			aux.Append(_L("Hostfile "));

		if (flags & EDnsServer)

			aux.Append(_L("DNS "));

		if (flags & EDnsHostName)

			aux.Append(_L("MyName "));

		if (flags & EDnsCache)

			aux.Append(_L("Cached "));

		aux.Append(')');

		}

	aux.Append(_L("\n"));

	iConsole->WriteLine(aux);

	iCount++;

	if (src_addr)

		{

		// Show a matching SRC address.

		RSocket socket;

		TPckgBuf<TSoInetIfQuery> opt;

		opt().iDstAddr = iHostAddr;

		if (socket.Open(iSockServ, KAfInet, KSockDatagram, KProtocolInetUdp) == KErrNone)

			{

			_LIT(KIsVIF, " (VIF)");

			_LIT(KIsIF, "");

			_LIT(KNoRoute, "(no route)");

			(void)socket.GetOpt(KSoInetIfQueryByDstAddr, KSolInetIfQuery, opt);

			socket.Close();

			opt().iSrcAddr.OutputWithScope(textIPaddress);

			aux.Format(_L("   src= %S @ %S%S\n"), &textIPaddress, &opt().iName,

				opt().iName.Length() == 0 ? &KNoRoute() : opt().iIsUp ? &KIsIF() : &KIsVIF());

			iConsole->WriteLine(aux);

			}

		else

			iConsole->WriteLine(_L("cannot find src, UDP socket open failed\n"));

		}

	//

	// Get next address

	//

	iHostResolv.Next(iEntry, iStatus);

	SetActive();

	}

void CNslookup::DoCancel()

	{

	// Called only from Cancel() if there is pending resolve going on... (IsActive())

	iHostResolv.Cancel();

	}

// Outputs some text about the Query() response to the console

void CNslookup::QueryResponse()

	{

	TBuf<256> aux;

	TBuf<128> addrbuf;

	if (iResult.Length() < (TInt)sizeof(TDnsQryRespBase))

		{

		aux.AppendFormat(_L("Malformed response (length: %d)\n"), iResult.Length());

		return;

		}

	TDnsQryRespBase *respbase = (TDnsQryRespBase *)iResult.Ptr(); //lint !e826 // area length checked above

	aux.Append(iHostname);

	aux.AppendFormat(_L(": cl: %d  ttl: %d  "),

			respbase->RRClass(), respbase->RRTtl());

	// ugh... I'll do this the hard way: temporary buffer for converting from 8-bit

	// DNS result descriptors to 16-bit descriptor and the append to output buffer.

	// A better solution will follow a bit later...

	switch(respbase->RRType())

		{

	case KDnsRRTypeA:

		{

		const TDnsRespA *const respA = (TDnsRespA *) respbase;

		respA->HostAddress().Output(addrbuf);

		aux.Append(_L("type: A  "));

		aux.Append(_L("addr: "));

		aux.Append(addrbuf);

		}

		break;

	case KDnsRRTypeAAAA:

		{

		const TDnsRespAAAA *const respAAAA = (TDnsRespAAAA *) respbase;

		respAAAA->HostAddress().Output(addrbuf);

		aux.Append(_L("type: AAAA  "));

		aux.Append(_L("addr: "));

		aux.Append(addrbuf);

		}

		break;

	case KDnsRRTypePTR:

		{

		const TDnsRespPTR *const respPTR = (TDnsRespPTR *) respbase;

		aux.Append(_L("type: PTR  "));

		aux.Append(_L("name: "));

		addrbuf.Copy(respPTR->HostName());

		aux.Append(addrbuf);

		}

		break;

	case KDnsRRTypeMX:

		{

		const TDnsRespMX *const respMX = (TDnsRespMX *) respbase;

		aux.Append(_L("type: MX  "));

		aux.AppendFormat(_L("pref: %d  "), respMX->Pref());

		aux.Append(_L("name: "));

		addrbuf.Copy(respMX->HostName());

		aux.Append(addrbuf);

		}

		break;

	case KDnsRRTypeSRV:

		{

		const TDnsRespSRV *const respSRV = (TDnsRespSRV *) respbase;

		aux.Append(_L("type: SRV  "));

		aux.AppendFormat(_L("prio: %d  wght: %d  port: %d  targ: "),

				respSRV->Priority(), respSRV->Weight(), respSRV->Port());

		addrbuf.Copy(respSRV->Target());

		aux.Append(addrbuf);

		}

		break;

	case KDnsRRTypeNAPTR:

		{

		const TDnsRespNAPTR *const respNAPTR = (TDnsRespNAPTR *) respbase;

		aux.Append(_L("type: NAPTR  "));