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

// cmdnsclient.cpp

// 

//

/**

@file

@PublishedAll

*/

//User include 

#include "cmdnsclient.h"

#include "cmdnsserverconstants.h"

//System include

#include <mdns/dnsconstants.h>

#include <s32mem.h>

#include <in_sock.h>

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

/*

 * Default constructor -Assigns the buffer pointer to Null 

 */

EXPORT_C RMdns::RMdns():iBufPointer(NULL,0)

	{

	__FLOG_OPEN(KMDNSSubsystem, KComponent);

	}

/*

 * Interface to start the Mdns server .

 * KMdnsServerName referes to the name of the Mdns server.

 * @param aConnectionHandle handle to the RConnection object // TODO

 * @param aSocketServerHandle handler to the RSocketServ object //TODO 

 * 

 */

EXPORT_C TInt RMdns::Open(TInt aConnectionHandle)

	{

	__FLOG(_L8("RMdns::Open - Entry"));

	TVersion serverVersion(0, 0, 0);

	//creates a new session if the server exists and it is up and running .

	//returns KErrNotFound if the server needs to be launched.

	TInt err = CreateSession(KMdnsServerName, serverVersion, 2);

	if (err == KErrNotFound)

		{

		// try starting the server, since create session didn't work

		//iap refers to the iap application wants to use.

		TBuf<16> iap;

		iap.AppendNum(aConnectionHandle);

		RProcess server;

		User::LeaveIfError(server.Create(KMdnsServerExe, iap));

		server.Resume();

		TRequestStatus status;

		status = KRequestPending;

		server.Rendezvous(status);

		//waits for the server to construct all the required object.

	 	User::WaitForRequest(status);

		User::LeaveIfError(status.Int());

		User::LeaveIfError(CreateSession(KMdnsServerName, serverVersion, 2));

		server.Close();

		}

	else

		{

		User::LeaveIfError(err);

		}

	iNotifierCount =0;

	//creates a buffer object with buffer length KDnsBufferlength = 1000 this is the max application

	//could send stored in the bundle.

	iBuffer = HBufC8::NewL(KDnsBufferlength);

	//Set the pointer to point buffer.

	iBufPointer.Set(iBuffer->Des());

	//Create a notifier which will be used to catch all the publish and 

	// query response . There will be only one eventobserver for the client.

	//Will be destroyed when the client will be closed.

	TRAPD(error,iEventNotifier = CMdnsQueryPublishNotifier::NewL(*this));

	__FLOG(_L8("RMdns::Open - Exit"));

	return error;

	}

/*

 * Hanldes any queries either the ptr ,srv txt and address record

 * IN case of PTR query will be send to the network . 

 * For SRV and TXT if it exist in the cache ,request will be completed immediately .

 * @param aQueryParams contains the query bundle.

 * Leaves with KErrAlreadyExists if a request is pending.

 */

EXPORT_C void RMdns::QueryL( const RPnPParameterBundle& aQueryParams )

	{

	__FLOG(_L8("RMdns::QueryL - Entry"));

	//Get the status of the event notifies . If it is KRequestPending 

	//there exists a query which needs to be completed . 

	//Leaves with KErrAlreadyExist if there is query which is pending.

	TRequestStatus &status =  iEventNotifier->EventNotifierStatus();

	if( status.Int() == KRequestPending)

        {

        User::Leave(KErrAlreadyExists);

        }

	//Set the buffer pointer to zero and convert bundle in to buffer and store it in buffer.

	iBufPointer.Zero();

	TInt temp = aQueryParams.Length();

	aQueryParams.Store(iBufPointer);

	//TODO

	//Create a reference to buffer length and send it along the with the request.

	//On completion contains the length of the buffer client should create to get the 

	//response for the query.

	//TPckg<TInt> len(iEventNotifier->BufferLength());

	TIpcArgs args(&iBufPointer,&iEventNotifier->BufferLength());

	//Set Event notifier active

	iEventNotifier->SetEventNotifierActive();

	iEventNotifier->SetPnpObserver(aQueryParams.PnPObserver());

	//Set the state as query message so that on response it can decide wheteher it is query or publish.

	iEventNotifier->SetState(EMdnsServerQueryMessages);

	TRAPD(error,SendReceive(EMdnsServerQueryMessages,args, status));

	__FLOG(_L8("RMdns::QueryL - Exit"));

	}

//TODO yet to decide wat to do with this 

//as query itself can handle all the requests

EXPORT_C void RMdns::ResolveL( const RPnPParameterBundle& aResolveParams )

	{

	__FLOG(_L8("RMdns::ResolveL - Entry"));

	QueryL(aResolveParams);

	__FLOG(_L8("RMdns::ResolveL - Exit"));

	}

/*

 * Interferace for the applicaion to register for a particular service it serves

 * on the network , A copy of this will be kept in the cache .

 * applicaion dont have to renew the service .Consistency Manager will take care of renewing the service.

 * @param aPublishParam contains the srv record and the txt record if required need to be published.

 * 

 */

EXPORT_C void RMdns::RegisterServiceL( const RPnPParameterBundle& aPublishParams ,TBool aIsUpdate)

	{

	__FLOG(_L8("RMdns::RegisterServiceL - Entry"));

	iBufPointer.Zero();

	aPublishParams.Store(iBufPointer);

	TIpcArgs args(&iBufPointer,&iEventNotifier->BufferLength(),aIsUpdate);

	iEventNotifier->SetEventNotifierActive();

	iEventNotifier->SetPnpObserver(aPublishParams.PnPObserver());

	TRequestStatus &status =  iEventNotifier->EventNotifierStatus();

	iEventNotifier->SetState(EMndsServerPublishMessages);

	TRAPD(error,SendReceive(EMndsServerPublishMessages,args,status));

	User::LeaveIfError(error);

	__FLOG(_L8("RMdns::RegisterServiceL - Exit"));

	}

/*

 * An Asychronous request which tells the mdns about the service it is interested in .

 * Internally it calls RecieveNotifyMessageL which is a private function, feasible only to CMDnsregisterNotifier

 * CMDnsRegisterNotifier is an active object running all the time waiting for any ptr enteries.

 * @param aNotifyParam contains the ptr type the application is interrested in ;to be notified.

 */

EXPORT_C void RMdns::WaitForNotificationL( const RPnPParameterBundle& aNotifyParams )

	{

	__FLOG(_L8("RMdns::WaitForNotificationL - Entry"));

	if(!iRegisterNotifier)

        {

        iRegisterNotifier = CMdnsRegisterNotifier::NewL(*this);

        }

	iRegisterNotifier->SetPnpObserver(aNotifyParams.PnPObserver());

	HBufC8* buffer  = HBufC8::NewL(KDnsBufferlength);

	TPtr8 aNotifyMessage(NULL,0,0);

	aNotifyMessage.Set(buffer->Des());

	aNotifyParams.Store(aNotifyMessage);

	TIpcArgs args(&aNotifyMessage);

	SendReceive(EMdnsServerStartNotifyMessages,args);

	iNotifierCount++;

	delete buffer;

	__FLOG(_L8("RMdns::WaitForNotificationL - Exit"));

	}

/*

 *Interface to cancel any notification client requested for .

 *@param aCancelParams contains the name of the ptr type client is not interested to be notified.

 * 

 */	

EXPORT_C TInt RMdns::Cancel( const RPnPParameterBundle& aCancelParams )

	{

	__FLOG(_L8("RMdns::Cancel - Entry"));

	//notifier count keeps track of the number of entries requested for.

	iNotifierCount--;

	HBufC8* buffer  = HBufC8::NewL(KDnsBufferlength);

	TPtr8 aNotifyMessage(NULL,0,0);

	aNotifyMessage.Set(buffer->Des());

	aCancelParams.Store(aNotifyMessage);

	TIpcArgs args(&aNotifyMessage);

	SendReceive(EMdnsServerStopNotifyMessages,args);

	//when notifier count is zero close the CMdnsRegisterNotifier active object.

	//count =0 means the concerned client is not interested in any notification.

	if(iNotifierCount == 0)

	    {

	    iRegisterNotifier->Cancel();

	    }

	delete buffer;

	__FLOG(_L8("RMdns::Cancel - Exit"));

	return KErrNone;

	}

/*

 * Destructor 

 */	

EXPORT_C TInt RMdns::Close()

	{

	__FLOG(_L8("RMdns::Close - Entry"));

	RSessionBase::Close(); 

	delete iEventNotifier;

	delete iRegisterNotifier;

	delete iBuffer;

	__FLOG(_L8("RMdns::Close - Exit"));

	__FLOG_CLOSE;

	return KErrNone;

	}

/*

 * Private function used by the Query and publish notifier .

 * Based on the size of the buffer recieved by the query and publish request.

 * a new buffer is allocated and sent to recieve the response.

 * @param aData contains the buffer allocated to recieve the response.

 */

void RMdns::RecieveMessage(TDes8& aData)

	{

	__FLOG(_L8("RMdns::RecieveMessage - Entry"));

	TIpcArgs args(&aData);

	TRAPD(error,SendReceive(EMdnsServerRecieveMessages,args));	

	__FLOG(_L8("RMdns::RecieveMessage - Exit"));

	}

/*

 * An synchronous request will be running all the time . whenever a waitfornotification been called.

 * @param aData contains the buffer for which data to be set to .

 * @param aStatus used to complete the asynchronous request.

 */

void RMdns::RecieveNotifyMessageL(TDes8& aData,TRequestStatus& aStatus)

    {

    __FLOG(_L8("RMdns::RecieveNotifyMessageL - Entry"));

    TIpcArgs args(&aData);

    SendReceive(EMdnsServerRecieveNotifyMessages,args,aStatus);

    __FLOG(_L8("RMdns::RecieveNotifyMessageL - Exit"));

    }