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

// csockethandler.cpp

// 

//

/**

@file

@internalTechnology

*/

//User include

#include "csockethandler.h"

#include <mdns/cdnsmessagecomposerparser.h>

#include <mdns/cdnsmessage.h>

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

/**

Two-phase construction method

@param 	aSocket Reference to  RSocket

@param 	aObserver Reference to  MSocketHandlerObserver used to notify the client.

@param 	aOperation TSocketOperation specfies the operation socket should perform.

@return a pointer to the requested socket handler object

*/

CSocketHandler* CSocketHandler::NewL(RSocket& aSocket, MSocketHandlerObserver& aObserver, TSocketOperation aOperation)

 	{

 	CSocketHandler* self = new (ELeave)CSocketHandler(aSocket, aObserver, aOperation);

 	CleanupStack::PushL(self);	

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 /**

 Destructor

 */

CSocketHandler::~CSocketHandler()

	{

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

	Cancel();

	delete iPacketBuffer;

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

	__FLOG_CLOSE;

	}

/**

This to activate the socket to perform either send or recieve based on the operation set.

@param aParams Reference to TSocketHandlerParams containing operation,packet and address

@return void

*/	

void CSocketHandler::Activate ( const TSocketHandlerParams& aParams )

	{

	__FLOG(_L8("CSocketHandler::Activate - Entry"));

	iOperation = static_cast < TSocketOperation > ( aParams.iArgs[0] );

	switch ( iOperation )

		{

		case ESocketSend:

			{

			iPacketPtr.Zero();

			HBufC8* bufChain = reinterpret_cast < HBufC8* > ( aParams.iArgs[1] );

			iLength = 0;

			iSocket.Send(*bufChain, KDefaultFlags, iStatus, iLength );

			}

		break;

		case ESocketSendTo:

			{

			iPacketPtr.Zero();

			RBuf8* bufChain = reinterpret_cast < RBuf8* > ( aParams.iArgs[1] );

			iSockAddr = *(reinterpret_cast < TSockAddr* > ( aParams.iArgs[2] ));

			iLength = 0;

			iSocket.SendTo ( *bufChain, iSockAddr, KDefaultFlags, iStatus, iLength );

			}

		break;

		case ESocketRecieve:

			{

			iPacketPtr.Zero();

			iSocket.Recv (iPacketPtr, KDefaultFlags, iStatus );

			}

		break;

		case ESocketRecieveFrom:

			{

			iPacketPtr.Zero();

			iSocket.RecvFrom ( iPacketPtr, iSockAddr, KDefaultFlags, iStatus );

			}

		break;

		default:

			User::Invariant ();

		};

	SetActive();

	__FLOG(_L8("CSocketHandler::Activate - Exit"));

	}

/**

*/

void CSocketHandler::CompleteSelf ( TInt aError )

	{

	__FLOG(_L8("CSocketHandler::CompleteSelf - Entry"));

    TRequestStatus* pStat = &iStatus;

    User::RequestComplete ( pStat, aError );

	SetActive ( );

	__FLOG(_L8("CSocketHandler::CompleteSelf - Exit"));

    }

/**

Constructor

*/

CSocketHandler::CSocketHandler(RSocket& aSocket, MSocketHandlerObserver& aObserver, TSocketOperation aOperation):CActive ( EPriorityNormal ),iSocket(aSocket),iObserver(aObserver),iOperation(aOperation),iPacketPtr(NULL,0)

	{

	}

/**

Constructs a heap to hold the packet of almost 9k size

*/

void CSocketHandler::ConstructL()

	{

	__FLOG_OPEN(KMDNSSubsystem, KComponent);

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

	// Allocate a 9K buffer to contain the biggest mDNS packet allowable

	iPacketBuffer = HBufC8::NewL(KMaxDnsPacketSize);

	iPacketPtr.Set(iPacketBuffer->Des());	

	CActiveScheduler::Add(this);

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

	}

/**

cancels the current operation

*/

void CSocketHandler::CancelCurrent()

	{

	__FLOG(_L8("CSocketHandler::CancelCurrent - Entry"));

	switch ( iOperation )

		{

		case ESocketSend:	

		case ESocketSendTo:

			iSocket.CancelSend ();

		break;

		case ESocketRecieve:

		case ESocketRecieveFrom:

			iSocket.CancelRecv ();

		break;

		};

	__FLOG(_L8("CSocketHandler::CancelCurrent - Exit"));

	}

/**

Notifies the client with parameters based on the operation.

a.	Returns the packet and addres for recieve operation.

b.	returns only length of data send for send operation.

*/

void CSocketHandler::NotifyCompletionL( )

	{

	__FLOG(_L8("CSocketHandler::NotifyCompletionL - Entry"));

	switch ( iOperation )

		{

		case ESocketSend:	

			{

			iObserver.OnCompletionL(iPacketPtr,NULL,iLength());

			break;

			}

		case ESocketSendTo:

			{

			iObserver.OnCompletionL(iPacketPtr,iSockAddr,iLength());

			break;

			}

		case ESocketRecieve:

		case ESocketRecieveFrom:		

			{

			iObserver.OnCompletionL(iPacketPtr,iSockAddr,iLength());

			break;

			}

		};

	__FLOG(_L8("CSocketHandler::NotifyCompletionL - Exit"));

	}

/**

Notifies the client after the send or recieve  	

//Derived from CActive

*/

void CSocketHandler::RunL()

	{

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

	TInt err = iStatus.Int ();

	if ( err == KErrNone )

		{

		NotifyCompletionL();

		}

	else

		{

		iObserver.OnError ( err );

		}

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

	}

/**

Derived from CActive

Cancellation of an outstanding request.

*/	

void CSocketHandler::DoCancel()

	{

	__FLOG(_L8("CSocketHandler::DoCancel - Entry"));

	CancelCurrent ();

	__FLOG(_L8("CSocketHandler::DoCancel - Exit"));

	}

/**

Handles any leave from the RunL

@param aError Error with which Runl leaves

@return error 

*/	

TInt CSocketHandler::RunError(TInt /*aError*/)

	{

	__FLOG(_L8("CSocketHandler::RunError - Entry"));

	//__ASSERT_DEBUG(aError,User::Invariant());

	//Ignore any leave from RSocket

	__FLOG(_L8("CSocketHandler::RunError - Exit"));

	return KErrNone;

	}