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

// cmessagehandler.cpp

// 

//

/**

@file

@internalTechnology

*/

//System include

#include <mdns/cdnsmessagecomposerparser.h>

#include <mdns/cdnsmessage.h>

#include <e32base.h>

//user include

#include "cmessagehandler.h"

#include "cqueryhandler.h"

#include "ccacheentry.h"

#include "cresponsehandler.h"

#include "cadvertizehandler.h"

#include <mdns/mdnscachemgr.h>

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

//

/**

Two phase constructor 

@param aServer reference to CBonjourServer

@return pointer to CMessageHandler

*/

CMessageHandler* CMessageHandler::NewL(CMdnsServer& aServer)

	{

	CMessageHandler* self = new (ELeave) CMessageHandler(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Implementation of MSocketHandlerObserver 

@param aData packet recieved from the mdns port

@param aAddr address from which packet is recieved

@param aLength length of the packet reieved

@return void

*/		

void CMessageHandler::OnCompletionL(TDesC8& aData, const TSockAddr& aAddr, TInt aLength ) 

	{

	__FLOG(_L8("CMessageHandler::OnCompletionL - Entry"));

	HandleIncomingPacketL(aData ,aAddr ,aLength );

	iRecieveSocket->Activate(TSocketHandlerParams(ESocketRecieve));	

	__FLOG(_L8("CMessageHandler::OnCompletionL - Exit"));

	}

/**

Any error in the socket will be notified here

@paran aError error with which socket leaves

@return void

*/	

void CMessageHandler::OnError(TInt /*aError*/)

	{

	__FLOG(_L8("CMessageHandler::OnError -Entry Exit"));

	}

/**

Constructor

*/

CMessageHandler::CMessageHandler(CMdnsServer& aServer):iServer(aServer)

	{

	}

/**

Two phase constructor

*/	

void CMessageHandler::ConstructL()

	{

	__FLOG_OPEN(KMDNSSubsystem, KComponent);

	__FLOG(_L8("CMessageHandler::ConstructL - Entry"));

	iQueryHandler = CQueryHandler::NewL(*this);

	iResponseHandler = CResponseHandler::NewL(*this);

	iAdvertizeHandler = CAdvertizeHandler::NewL(*this);

	iRecieveSocket = CSocketHandler::NewL(iServer.Socket(),*this,ESocketRecieve);

	iSendMessageQueue = CSendMessageQueue::NewL(iServer.Socket());

	iRecieveSocket->Activate(TSocketHandlerParams(ESocketRecieve));	

	iDnsCache = CMDNSCacheManager::NewL(200);

	iDummyhandler = CBaseHandler::NewL(*this);

	__FLOG(_L8("CMessageHandler::ConstructL - Exit"));

	}

/*

Destructor

*/	

CMessageHandler::~CMessageHandler()

	{

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

	delete iQueryHandler;

	delete iResponseHandler;

	delete iAdvertizeHandler;

	delete iRecieveSocket;

	TRAPD(err,iDnsCache->DumpCacheL());

	delete iDnsCache;

	delete iPacket;

	delete iSendMessageQueue;

	delete iDummyhandler;

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

	__FLOG_CLOSE;

	}

/**

This method parse the packet and dispatch the packet for handling it based on the operation requested.

from the header

@param aData packet read from the mdns port

@param aAddr address from which the packet is recieved

@param length lenght of the data recieved

@return void

*/	

void CMessageHandler::HandleIncomingPacketL(TDesC8& aData, const TSockAddr& aAddr, TInt /*length*/)

	{

	__FLOG(_L8("CMessageHandler::HandleIncomingPacketL - Entry"));    

	CDnsMessageComposerParser* comPos = CDnsMessageComposerParser::NewL();	

	CleanupStack::PushL(comPos);

	CDnsMessage* message = comPos->ParseMessageL(aData);

	CleanupStack::PushL(message);

	CBaseHandler& iOperationHandler = GetHandlerL(*message);

	iOperationHandler.HandleIncomingPacketL(*message ,aAddr);	

	CleanupStack::PopAndDestroy(message);//comPos and message

	CleanupStack::PopAndDestroy(comPos);

	__FLOG(_L8("CMessageHandler::HandleIncomingPacketL - Exit"));

	}

/**

This is a factory method which reads the packet and returns the handle to either

response or query handler

@param aMessage Dnspacket to read the header and to constructthe appropriate handler.

@return Poointer to CBaseHandler --base class to both response and query handler.

*/ 

CBaseHandler& CMessageHandler::GetHandlerL(CDnsMessage& aMessage)

	{

	__FLOG(_L8("CMessageHandler::GetHandlerL - Entry"));

	TDnsHeader header = aMessage.Header();

	//

	if(header.IsQuery() && !header.IsAuthoritative())

		{

		return 	*iQueryHandler;

		}

	else if(header.IsAuthoritative())

		{

		return *iResponseHandler;

		}

	else 

		{

		return *iDummyhandler;	

		}	

	__FLOG(_L8("CMessageHandler::GetHandlerL - Exit"));		

	}

/**

@return return a reference to CacheManager

*/

MDNSCacheMgr& CMessageHandler::DnsCache() const

	{

	__FLOG(_L8("CMessageHandler::DnsCache -Entry Exit"));

     return *iDnsCache;		

	}

/*

 * Routes the query sent by the client to query handler to handle it.

 * @param aMessage Pointer to a message object ;contains the query.

 * @param aHandle session id which generated the query.

 */

void CMessageHandler::ServiceClientQueryL(CDnsMessage* aMessage,TInt aHandle)

	{

	__FLOG(_L8("CMessageHandler::ServiceClientQueryL - Entry"));

	iQueryHandler->ServiceClientQueryL(aMessage, aHandle);

	__FLOG(_L8("CMessageHandler::ServiceClientQueryL - Exit"));

	}

/*

 * returns the pointer to the messagequeue.

 */

CSendMessageQueue& CMessageHandler::MessageQueue()const

	{

	__FLOG(_L8("CMessageHandler::MessageQueue -Entry Exit"));

	return *iSendMessageQueue;	

	}

/*

 * Notify the server after the query has been handled.

 * @param aClientHandle SessionId which had sent the query.

 */

void CMessageHandler::NotifyClientQuery(TInt aClientHandle)

	{

	__FLOG(_L8("CMessageHandler::NotifyClientQuery - Entry"));

	iServer.NotifyClientQuery(aClientHandle);	

	__FLOG(_L8("CMessageHandler::NotifyClientQuery - Exit"));

	}

/*

 * Route an internal query to the query handler

 * @param aMessage pointer to the dnsmeesage containg the query.

 * @param Observer to which successfull delivery of packet to be notified.

 */

void CMessageHandler::SendQueryL(CDnsMessage* aMessage, MMessageHandler& aObserver)

	{

	__FLOG(_L8("CMessageHandler::SendQueryL - Entry"));

	iQueryHandler->SendQueryL(aMessage, aObserver);	

	__FLOG(_L8("CMessageHandler::SendQueryL - Exit"));

	}

/*

 * Route the packet to be advertised to the adveritser.

 * @param aData array of CDnsresourceData to be advertised.

 * @param aSessionId session which adveritised the packet.

 */			

void CMessageHandler::AdvertizePacketL(const RPointerArray<CDnsResourceData> aData, TInt aSessionId,TBool aIsUpdate)

    {

    __FLOG(_L8("CMessageHandler::AdvertizePacketL - Entry"));

    iAdvertizeHandler->AdvertizePacketL(aData, aSessionId,aIsUpdate);

    __FLOG(_L8("CMessageHandler::AdvertizePacketL - Exit"));

    }

/*

 * Notify the server when a new service is published

 * @param aName name of the service published

 * inacase of autoresolve name will be the new published name.

 * @param aError will be the result of publish.ESuccess if successfull and E*Conflict.

 * @param aSessionId session which initaiated publish.

 * 

 */

void CMessageHandler::NotifyServicePublishL(const RBuf8& aName,TInt aError, TInt aSessionId)

    {

    __FLOG(_L8("CMessageHandler::NotifyServicePublishL - Entry"));

    iServer.NotifyServicePublishL(aName,aError, aSessionId);

    __FLOG(_L8("CMessageHandler::NotifyServicePublishL - Exit"));

    }

/*

 * @param aProbing ETrue if hostprobing in progress.

 */

void CMessageHandler::SetStateHostProbing(TBool aProbing)

    {

    __FLOG(_L8("CMessageHandler::SetStateHostProbing - Entry"));

    iServer.SetStateHostProbing(aProbing);

    __FLOG(_L8("CMessageHandler::SetStateHostProbing - Exit"));

    }

/* 

 * notify the server when a new service has been published in the network

 * @param aName array of new service published , for the servcetype client has requested.

 */

void CMessageHandler::NotifyNewServiceL(const RArray<RBuf8>& aName)

    {

    __FLOG(_L8("CMessageHandler::NotifyNewServiceL - Entry"));

    iServer.NotifyNewServiceL(aName);

    __FLOG(_L8("CMessageHandler::NotifyNewServiceL - Exit"));

    }

CMdnsServer& CMessageHandler::Server()

    {

    return iServer; 

    }