// Copyright (c) 2008-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:

// cmdnsprobemanager.cpp

// 

//

/**

@file

@internalTechnology

*/

//User include 

#include "e32math.h" 

#include "cmdnsprobemanager.h"

//System include

#include <mdns/ccacheentry.h>

__FLOG_STMT(_LIT8(KComponent,"MDNSServer");)

/*

 * Two phase constructor

 * @param aCache reference to cache

 * @param aMessageHandler reference to message handler.

 * @param aAutoresolveEnabled True if name conflict to be handled.

 */

CMDNSProbeManager* CMDNSProbeManager::NewL(MDNSCacheMgr& aCache,CMessageHandler& aMessageHandler,TBool aAutoResolveEnabled)

	{

	CMDNSProbeManager* self = CMDNSProbeManager::NewLC(aCache,aMessageHandler,aAutoResolveEnabled);

	CleanupStack::Pop(self);

	return self;

	}

static void CleanUpCache(TAny* aAny)

    {

    RPointerArray <CCacheEntry> * records = static_cast < RPointerArray <CCacheEntry>* > (aAny);

    records->ResetAndDestroy();

    records->Close();

    }

/*

 * Two phase constructor

 * @param aCache reference to cache

 * @param aMessageHandler reference to message handler.

 * @param aAutoresolveEnabled True if name conflict to be handled.

 */

CMDNSProbeManager* CMDNSProbeManager::NewLC(MDNSCacheMgr& aCache,CMessageHandler& aMessageHandler,TBool aAutoResolveEnabled)

	{

	CMDNSProbeManager* self = new (ELeave)CMDNSProbeManager(aCache,aMessageHandler,aAutoResolveEnabled);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/*

 * Constructor

 */

CMDNSProbeManager::CMDNSProbeManager(MDNSCacheMgr& aCache,CMessageHandler& aMessageHandler,TBool aAutoResolveEnabled)

:CTimer(CActive::EPriorityStandard),iCache(aCache),iMessageHandler(aMessageHandler),iAutoResolveEnabled(aAutoResolveEnabled)

	{

	CActiveScheduler::Add(this);

	}

/*

 * Two phase Constructor

 */

void CMDNSProbeManager::ConstructL()

	{

	__FLOG_OPEN(KMDNSSubsystem, KComponent);

	CTimer::ConstructL();

	iCurrentProbeState = EIdle;

	}

/*

 * Destructor

 */

CMDNSProbeManager::~CMDNSProbeManager()

	{

	__FLOG(_L8("CMDNSProbeManager::~CMDNSProbeManager - Entry"));

	iName.Close();

	iTarget.Close();

	iProbeName.Close();

	iProbeType.Close();

	__FLOG(_L8("CMDNSProbeManager::~CMDNSProbeManager - Exit"));

	__FLOG_CLOSE;

	}

/*

 * State machine which probe send announcement and handle conflicts 

 * if autoresolve enabled.

 */

void CMDNSProbeManager::RunL()

	{	

	__FLOG(_L8("CMDNSProbeManager::RunL - Entry"));

	TTime currentTime;

	if(iCurrentProbeState <= EProbeComplete)

		{

		if(DefensiveResponseL())

			{		

			iCurrentProbeState = EStart;				

			if(iAutoResolveEnabled)

				{

				GenerateNonConflictingName();	

				}		

			//	else { }//  to intimate server of failure

			if(iProbeCounter >= KMaxFailures)

				{

				//If Probe Failure rate is greater then 15 per second, wait for 

				//5 seconds before probing again

				iProbeCounter = 0;

				After(5*1000*1000);				

				}

			}		

		}

	switch(iCurrentProbeState)

		{		

		case EIdle:

		break;//Do Nothing

		case EStart:

			{

			currentTime.UniversalTime();

			TInt64 randseed = currentTime.Int64();					

			//Random time between 0 & 250 ms

			TInt delay = Math::Rand(randseed) % 250;

			iCurrentProbeState = EProbeFirstUnicast;

			//Convert to microsecond

			After(delay*1000);			

			}				

			break;

		case EProbeFirstUnicast:

			{

			SendProbeL(ETrue);	

			iCurrentProbeState = EProbeSecondUnicast;							

			}

			break;

		case EProbeSecondUnicast:

			{				

			SendProbeL(ETrue);	

			iCurrentProbeState = EProbeMulticast;										

			}

			break;		

		case EProbeMulticast:

			{

			SendProbeL(EFalse);	

			iCurrentProbeState = EProbeComplete;			

			}

			break;

		case EProbeComplete:

			{

			iCurrentProbeState = EFirstAnnouncement;

			//Probe succeeded ,insert in cache 

			InsertInCache();

			iMessageHandler.Server().SetHostNameL(iName);

			After(KProbeDelay*1000);

			//Some Delay ?? Required or defensive response HAS TO come within 750ms?

			}

			break;

		case EFirstAnnouncement:

			{

			SendAnnouncementL();

			iCurrentProbeState = ESecondAnnouncement;

			//After(1000);// A Millisecond delay: Required??	

			}

			break;

		case ESecondAnnouncement:

			{

			SendAnnouncementL();

			iCurrentProbeState = EIdle;

			}

			break;	

		}

	__FLOG(_L8("CMDNSProbeManager::RunL - Exit"));

	}

/*

 * Handles any leave from RunL

 */

TInt CMDNSProbeManager::RunError(TInt aError)

	{

	__FLOG(_L8("CMDNSProbeManager::RunError - Entry Exit"));

	return aError;

	}

/*

 * Probe host

 * @param aUnicast True if unicast or else multicast.

 */

void CMDNSProbeManager::SendProbeL(TBool aUnicast)

	{

	__FLOG(_L8("CMDNSProbeManager::SendProbeL - Entry"));

	//Construct DNS Message

	CDnsMessage* message = CDnsMessage::NewL(0,ETrue);

	CleanupStack::PushL(message);

	//Form the Query/Question part of the message

	CDnsQuestion* question = CDnsQuestion::NewL();

	CleanupStack::PushL(question);

	question->SetNameL(iName);

	question->SetClass(EDnsClass_IN);

	question->SetType(EDnsQType_Any);

	if(aUnicast)

		{

		question->SetUnicast(ETrue);

		}

	//Append the Query to the Message

	message->AppendQueryL(question);

	//Form the Record to be filled in the Authoritative Field of the Query

	switch(iType)

	{

	case EDnsType_A:

		{

		CRdTypeA* addRec = FormAddressRecordL();			

		//Append to the Authoritative Section

		message->AppendAuthorityL(addRec);

		}

		break;

	case EDnsType_SRV:

		{							

		CRdTypeSrv* srvRec = FormServiceRecordL();

		//Append to the Authoritative Section

		message->AppendAuthorityL(srvRec);	

		}

		break;			

	}		

	//Send the query

	iMessageHandler.SendQueryL(message,*this);

	CleanupStack::Pop();//question

	CleanupStack::Pop();//message

	__FLOG(_L8("CMDNSProbeManager::SendProbeL - Exit"));

	}

/*

 * Send an announcement if probing is successfull.

 */

void CMDNSProbeManager::SendAnnouncementL()

	{

	__FLOG(_L8("CMDNSProbeManager::SendAnnouncementL - Entry"));

	RPointerArray<CCacheEntry> entries;

	//An API in Cache Interface that returns a list of all Authoritative records

	iCache.AuthoritativeEntriesL(entries);

	for(TInt index =0; index<entries.Count();index++)

		{

		CCacheEntry* entry = entries[index];

		//Send Announcements for all the Services we have published, and entered in Cache			

		CDnsMessage* message = CDnsMessage::NewL(0,EFalse);

		CleanupStack::PushL(message);			

	    TDnsHeader header(message->Header());

	    header.SetAuthoritative(ETrue);

	    message->SetHeader(header);

		if(entry->AddressRecord())

		    message->AppendAnswerL(entry->AddressRecord()->CloneL());

		if(entry->ServiceRecord())

		    message->AppendAnswerL(entry->ServiceRecord()->CloneL());

		if(entry->PtrRecord())

		    message->AppendAnswerL(entry->PtrRecord()->CloneL());

		if(entry->TxtRecord())

		    message->AppendAnswerL(entry->TxtRecord()->CloneL());

		//should've been a new API sendresponse

		iMessageHandler.SendQueryL(message,*this);

		CleanupStack::Pop();//message

		entries.ResetAndDestroy();

		entries.Close();

		}

	__FLOG(_L8("CMDNSProbeManager::SendAnnouncementL - Exit"));

	}

/*

 * Returns ture hostname exists in the cache.

 * True means there is already a record in the network with the same name.

 */

TBool CMDNSProbeManager::DefensiveResponseL()

	{

	__FLOG(_L8("CMDNSProbeManager::DefensiveResponseL - Entry"));

	TBool probeFailed(EFalse);		

	RPointerArray <CCacheEntry> entries;

	CleanupStack::PushL(TCleanupItem(TCleanupOperation(&CleanUpCache),&entries));

	_LIT8(KDot,".");

	TBuf8 <KMaxLength> buffer;	

	buffer.Copy(iName);

	buffer.Append(KDot);

	iCache.FindServiceL(entries,buffer,EDnsQType_Any);

	if(entries.Count()>0)

		{

		probeFailed = ETrue;

		}

    CleanupStack::PopAndDestroy();

    entries.ResetAndDestroy();

    entries.Close();	

    __FLOG(_L8("CMDNSProbeManager::DefensiveResponseL - Exit"));

	return probeFailed;

	}

TInt CMDNSProbeManager::StartNameProbeL(const TDesC8& aHostName,TInetAddr aAddr)

	{

	__FLOG(_L8("CMDNSProbeManager::StartNameProbeL - Entry"));

	iName.Close();

	iName.CreateL(aHostName);

    iProbeName.Close();

    iProbeName.CreateL(KMaxLength);

    iProbeName.Append(iName);

	iAddr = aAddr;

	iCurrentProbeState =  EStart;

	iType = EDnsType_A; 

    iMessageHandler.SetStateHostProbing(ETrue);

	Schedule();

	__FLOG(_L8("CMDNSProbeManager::StartNameProbeL - Exit"));

	return KErrNone;

	}

/*

 * Start probing the service.

 */

TInt CMDNSProbeManager::StartServiceProbeL(const TDesC8& aServiceName,const TDesC8& aTargetMachine,TUint16 aPort)

	{

	__FLOG(_L8("CMDNSProbeManager::StartServiceProbeL - Entry"));

	iName.Close();

	iName.CreateL(aServiceName);

	iTarget.Close();

	iTarget.CreateL(aTargetMachine);

	iPort = aPort;

	iType = EDnsType_SRV;

	iCurrentProbeState =  EStart;

	Schedule();

	__FLOG(_L8("CMDNSProbeManager::StartServiceProbeL - Exit"));

	return KErrNone;

	}

/*

 * Callback method

 * Will be notified on successfully sending a packet to the network .

 * State will be EIdle when an address is successully announced twice.

 */

void CMDNSProbeManager::OnPacketSendL(TInt /*aError*/)

	{

	__FLOG(_L8("CMDNSProbeManager::OnPacketSendL - Entry"));

	if( iCurrentProbeState != EIdle)

	    {

	    After(KProbeDelay*1000);//Give more delay than this

	    return;

	    }

	iMessageHandler.SetStateHostProbing(EFalse);

	__FLOG(_L8("CMDNSProbeManager::OnPacketSendL - Exit"));

	}

/*

 * Create an address record

 * @return returns an address record created.

 */

CRdTypeA* CMDNSProbeManager::FormAddressRecordL()

	{

	__FLOG(_L8("CMDNSProbeManager::FormAddressRecordL - Entry"));

	CRdTypeA* addRec = CRdTypeA::NewL();

	CleanupStack::PushL(addRec);

	TInt dataLength(4);

	addRec->SetNameL(iName);	

	addRec->SetType(EDnsType_A);

	addRec->SetClass(EDnsClass_IN);

	addRec->SetFlushBit(EFalse);

	addRec->SetAddr(iAddr);

	addRec->SetTtl(120);

	CleanupStack::Pop();//addRec

	__FLOG(_L8("CMDNSProbeManager::FormAddressRecordL - Exit"));

	return addRec;

	}

/*

 * Create a service record

 * @return retrun the newly created service record.

 */

CRdTypeSrv* CMDNSProbeManager::FormServiceRecordL()

	{

	__FLOG(_L8("CMDNSProbeManager::FormServiceRecordL - Entry"));

	CRdTypeSrv* srvRec = CRdTypeSrv::NewL();

	CleanupStack::PushL(srvRec);

	srvRec->SetClass(EDnsClass_IN);

	srvRec->SetFlushBit(EFalse);

	srvRec->SetNameL(iName);

	srvRec->SetPort(iPort);	

	srvRec->SetPriority(/*Default Priority*/0 );

	srvRec->SetTargetL(iTarget);

	srvRec->SetTtl(120*60);

	srvRec->SetType(EDnsType_SRV);

	srvRec->SetWeight(/*Default Weight*/ 0);

	CleanupStack::Pop();//srvRec

	__FLOG(_L8("CMDNSProbeManager::FormServiceRecordL - Exit"));

	return srvRec;

	}

void CMDNSProbeManager::InsertInCache()

	{

	__FLOG(_L8("CMDNSProbeManager::InsertInCache - Entry"));

	TBuf8<KMaxLength> name;

	_LIT8(KDot,".");

	CDnsResourceData* data = NULL;

	switch(iType)

		{		

			case EDnsType_A:

			{	

			data = FormAddressRecordL();

			}

			break;

			case EDnsType_SRV:

			{

			data = FormServiceRecordL();

			}

			break;

		}		

	//Append  a "." at the end of the name

	name.Copy(iName);

	name.Append(KDot);	

	data->SetNameL(name);

	iCache.UpdateCacheL(*data,ETrue,0/*session Id*/);

	delete data;

	__FLOG(_L8("CMDNSProbeManager::InsertInCache - Exit"));

	}

/*

 * If autoresolve enable a non conflict name will be generated using this.

 * @return returns the probecount.

 */

TInt CMDNSProbeManager::GenerateNonConflictingName()

	{		

/*

	__FLOG(_L8("CMDNSProbeManager::GenerateNonConflictingName - Entry"));

	_LIT8(KDot,".");

	if(iProbeCounter)

		{

		//From 2nd time, chop the last 3 characters

		iProbeName.SetLength(iProbeName.Length() - 3);

		}

	++iProbeCounter;

	TBuf8 <KMaxLength> newName;

	newName.Append(iProbeName);

	_LIT8(KOpenBrace,"(");

	newName.Append(KOpenBrace);		

	newName.AppendNum(iProbeCounter);

	_LIT8(KCloseBrace,")");

	newName.Append(KCloseBrace);

	iProbeName.Close();	

	iProbeName.Create(KMaxNameLength);

	iProbeName.Append(newName);

	iName.Close();	

	iName.Create(KMaxLength);

	iName.Append(iProbeName);

	iName.Append(KDot);

	iName.Append(iProbeType);

	__FLOG(_L8("CMDNSProbeManager::GenerateNonConflictingName - Exit"));

	return iProbeCounter;			

*/	

	//-------------------------------------------------------

    __FLOG(_L8("CMDNSProbeManager::GenerateNonConflictingName- Entry"));

    _LIT8(KDot,".");

    ++iProbeCounter;

    TBuf8 <KMaxLength> newName;

    iName.Close();  

    iName.Create(KMaxLength);

    iName.Append(iProbeName);

    TInt pos = iName.Locate('.');