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

//

#include <bluetooth/logger.h>

#include "l2capSigPacketEcho.h"

#include "l2capSignalHandler.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);

#endif

//                   ECHO REQUEST COMMAND 

//For outgoing echo requests driven by an L2Cap IOCTL

HEchoRequest::HEchoRequest(RMBufChain& aCommand,

		  	               TUint8 aRTXTimerDuration,

	                       TUint16 aERTXTimerDuration)

 : HL2CapCommand(aCommand, aRTXTimerDuration, aERTXTimerDuration),

   iEchoResponseHandler(NULL)

	{

	LOG_FUNC

	}

/*static*/ HEchoRequest* HEchoRequest::New(RMBufChain& aData,

		  	                               TUint8 aRTXTimerDuration,

	                                       TUint16 aERTXTimerDuration)

	{

	LOG_STATIC_FUNC

	HEchoRequest* cmd = NULL;

	RMBufChain buf;

	buf.Assign(aData);

	TRAPD(rerr, buf.PrependL(KEchoRequestEmptyLength));

	if(rerr == KErrNone)

		{

		cmd = new HEchoRequest(buf, aRTXTimerDuration, aERTXTimerDuration);

		if(cmd)

			{

			// Setup message contents.

			cmd->SetCode(EEchoRequest);

			cmd->SetID(KUninitialisedID);

			cmd->WriteDataLength();

			}

		else

			{

			// Free the allocated buffer.

			buf.Free();

			}

		}

	return cmd;

	}		

/*static*/ HEchoRequest* HEchoRequest::New(TUint8 aRTXTimerDuration,

	                                       TUint16 aERTXTimerDuration)

	{

	LOG_STATIC_FUNC

	HEchoRequest* cmd = NULL;

	RMBufChain buf;

	TRAPD(rerr, buf.AllocL(KEchoRequestEmptyLength));

	if(rerr == KErrNone)

		{

		cmd = new HEchoRequest(buf, aRTXTimerDuration, aERTXTimerDuration);

		if(cmd)

			{

			// Setup message contents.

			cmd->SetCode(EEchoRequest);

			cmd->SetID(KUninitialisedID);

			cmd->WriteDataLength();

			}

		else

			{

			// Free the allocated buffer.

			buf.Free();

			}

		}

	return cmd;

	}	

/**

Verifies that the buffer contains a structurally correct command. 

This does not ensure that the content of the command is semantically valid.

@param aCommmand A new HL2CapCommand if the buffer contains a structurally valid command.

@param aBuffer The buffer containing the command

@return KErrNone if the command if created.

		KErrNoMemory if the command structure is valid but cannot be created.

		KErrCorrupt if the command structure is invalid.

*/

TInt HEchoRequest::NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand)

	{

	LOG_STATIC_FUNC

	// Firstly align the MBufChain.  The maximum size we can align the 

	// MBufChain to is the maximum MBuf size

	__ASSERT_COMPILE(KEchoRequestEmptyLength <= KMBufSmallSize);

	// We don't align the data as that way we don't need to worry about it being 

	// larger than one MBuf in size.  It doesn't need to be aligned anyway as the

	// only way the data is accessed is by being copied out.

	TInt length = aBuffer.Length();

	if(length >= KEchoRequestEmptyLength)

		{

		// Don't need to check result as we know that the MBufChain contains

		// at least length bytes as we asked first.

		(void)aBuffer.Align(KEchoRequestEmptyLength);

		aCommand = new HEchoRequest(aBuffer);

		if(aCommand)

			{

			return KErrNone;

			}

		else

			{

			return KErrNoMemory;

			}

		}

	else

		{

		// Dodge length!

		return KErrCorrupt;

		}	

	}

HEchoRequest::~HEchoRequest()

	{

	LOG_FUNC

	}

TBool HEchoRequest::ProcessCommand(CL2CapSignalHandler& aSignalHandler)

	{

	LOG_FUNC

	if(aSignalHandler.HandleEchoRequest(this))

		{

		// The command has been handled.  Delete it.

		delete this;

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

TInt HEchoRequest::GetData(RMBufChain& aData) const

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	if(DataLength() > KEchoRequestEmptyLength)

		{

		TRAP(rerr, iCommand.CopyL(aData, KEchoRequestEmptyLength));

		}

	else

		{

		rerr = KErrNotFound;

		}

	return rerr;

	}

//					ECHO RESPONSE COMMAND 

//Constructor to deal command coming in from remote side

HEchoResponse::HEchoResponse(RMBufChain& aCommand) 

 : HL2CapCommand(aCommand)

	{

	LOG_FUNC

	}

/*static*/ HEchoResponse* HEchoResponse::New(RMBufChain& aData, TUint8 aId)

	{

	LOG_STATIC_FUNC

	HEchoResponse* cmd = NULL;

	RMBufChain buf;

	buf.Assign(aData);

	TRAPD(rerr, buf.PrependL(KEchoResponseEmptyLength));

	if(rerr == KErrNone)

		{

		cmd = new HEchoResponse(buf);

		if(cmd)

			{

			// Setup message contents.

			cmd->SetCode(EEchoResponse);

			cmd->SetID(aId);

			cmd->WriteDataLength();

			}

		else

			{

			// Free the allocated buffer.

			buf.Free();

			}

		}

	return cmd;

	}		

/*static*/ HEchoResponse* HEchoResponse::New(TUint8 aId)

	{

	LOG_STATIC_FUNC

	HEchoResponse* cmd = NULL;

	RMBufChain buf;

	TRAPD(rerr, buf.AllocL(KEchoResponseEmptyLength));

	if(rerr == KErrNone)

		{

		cmd = new HEchoResponse(buf);

		if(cmd)

			{

			// Setup message contents.

			cmd->SetCode(EEchoResponse);

			cmd->SetID(aId);

			cmd->WriteDataLength();

			}

		else

			{

			// Free the allocated buffer.

			buf.Free();

			}

		}

	return cmd;

	}		

/**

Verifies that the buffer contains a structurally correct command. 

This does not ensure that the content of the command is semantically valid.

@param aCommmand A new HL2CapCommand if the buffer contains a structurally valid command.

@param aBuffer The buffer containing the command

@return KErrNone if the command if created.

		KErrNoMemory if the command structure is valid but cannot be created.

		KErrCorrupt if the command structure is invalid.

*/

TInt HEchoResponse::NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand)

	{

	LOG_STATIC_FUNC

	// Firstly align the MBufChain.  The maximum size we can align the 

	// MBufChain to is the maximum MBuf size

	__ASSERT_COMPILE(KEchoResponseEmptyLength <= KMBufSmallSize);

	// We don't align the data as that way we don't need to worry about it being 

	// larger than one MBuf in size.  It doesn't need to be aligned anyway as the

	// only way the data is accessed is by being copied out.

	TInt length = aBuffer.Length();

	if(length >= KEchoResponseEmptyLength)

		{

		// Don't need to check result as we know that the MBufChain contains

		// at least length bytes as we asked first.

		(void)aBuffer.Align(KEchoResponseEmptyLength);

		aCommand = new HEchoResponse(aBuffer);

		if(aCommand)

			{

			return KErrNone;

			}

		else

			{

			return KErrNoMemory;

			}

		}

	else

		{

		// Dodge length!

		return KErrCorrupt;

		}	

	}

HEchoResponse::~HEchoResponse()

	{

	LOG_FUNC

	}

TBool HEchoResponse::ProcessCommand(CL2CapSignalHandler& aSignalHandler)	// Handle incoming echo response

	{

	LOG_FUNC

	if(aSignalHandler.HandleEchoResponse(this))

		{

		// The command has been handled.  Delete it.

		delete this;

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

TInt HEchoResponse::GetData(RMBufChain& aData) const

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	if(DataLength() > KEchoResponseEmptyLength)

		{

		TRAP(rerr, iCommand.CopyL(aData, KEchoResponseEmptyLength));

		}

	else

		{

		rerr = KErrNotFound;

		}

	return rerr;

	}