// 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 "l2capLinkSignalHandler.h"

#include "l2capSAPSignalHandler.h"

#include "l2capSigPacketEcho.h"

#include "l2capSigPacketInformation.h"

#include "l2capSigPacketConnection.h"

#include "l2capSigPacketConfigure.h"

#include "l2capSigPacketDisconnection.h"

#include "l2capSigPacketCommandReject.h"

#include "l2capCommand.h"

#include "l2capMuxController.h"

#include "l2signalmgr.h"

#include "l2capEntityConfig.h"

#include "l2util.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);

#endif

CL2CapLinkSignalHandler* CL2CapLinkSignalHandler::NewL(CL2CAPMux* aMuxer)

	{

	LOG_STATIC_FUNC

 	CL2CapLinkSignalHandler* linkSigHandler=new (ELeave) CL2CapLinkSignalHandler(aMuxer);

	CleanupStack::PushL(linkSigHandler);

	linkSigHandler->ConstructL();

	CleanupStack::Pop();

	return linkSigHandler;

 	}

CL2CapLinkSignalHandler::~CL2CapLinkSignalHandler()

	{

	LOG_FUNC

	DeleteCommands(iPendingCommands);

	DeleteCommands(iCommandsAwaitingResponse);

	}

void CL2CapLinkSignalHandler::ConstructL()

	{

	LOG_FUNC

	}

// Disable warning WINS 4355: 'this' : used in base member initializer list

// This will not cause any problems in this usage and is preferable to the use of a

// non-owned pointer.

#pragma warning (disable: 4355)

CL2CapLinkSignalHandler::CL2CapLinkSignalHandler(CL2CAPMux* aMuxer)

 : CL2CapSignalHandler(aMuxer),

   iPeerL2CapEntityConfig(*this),

   iSigMTU(KL2MinMTU)

	{

	LOG_FUNC

	}

#pragma warning (default: 4355)

TBool CL2CapLinkSignalHandler::HandleConnectionRequest(HConnectionRequest* aConnectionRequest)

	{

	LOG_FUNC

	const TL2CAPPort scid = aConnectionRequest->SourceCID(); 

	const TInt8 id = aConnectionRequest->ID();

	TBool scidValid = ETrue;

	if(scid < KL2CapDynamicCIDStart)	   

		{

		scidValid = EFalse;

		}

	else

		{

		CL2CapSAPSignalHandler* listeningSH = iMuxer->MuxController().FindListeningSignalHandler(aConnectionRequest->PSM());

		if(!listeningSH)

			{

			// Create a Connection Response Command

			HL2CapCommand* command = HConnectionResponse::New(id, 0, scid, EConnectPSMNotSupported);

			if(command)

				{

				AddToOutgoingQueue(command);

				}

			}

		else

			{

			// Does given CID already exist in the queue?

			CL2CapSAPSignalHandler* sh = iMuxer->GetSignalHandlerWithRemoteCID(scid);

			if (sh)

				{

				// ... it does: check whether the Connection Request is a retransmission

				// (and retransmit the response if so), or a new command (illegal - send CmdRej).

				if (!sh->IsDuplicateCommandRequest(aConnectionRequest))

					{

					LOG1(_L("Received a new Connection Request for an existing CID: 0x%04x"), scid)

					scidValid = EFalse;

					}

				}

			else

				{

				LOG1(_L("Remote CID (0x%04x) is free"),scid)

				// Usual case, remote CID is free.

				TInt err = listeningSH->PassiveConnectionRequest(iMuxer->RemoteBTAddr(), aConnectionRequest);

				if(err != KErrNone)

					{

					HL2CapCommand* command = HConnectionResponse::New(id, 0, scid, EConnectPSMNotSupported);

					if(command)

						{

						AddToOutgoingQueue(command);

						}

					}

				// If the command could not be created the connection will fail in the

				// signalling state machine.

				}

			}

		}

	if (!scidValid)

		{

		TL2CAPCommandRejectData reason;

		reason.iReason = EInvalidCID;

		reason.iLocalEndpoint = 0;

		reason.iRemoteEndpoint = scid;

		reason.iMTUExceeded = 0;

		HL2CapCommand* command = HCommandReject::New(reason, id);

		if(command)

			{

			AddToOutgoingQueue(command);

			}

		}

	// Always return true.  This is the only signal handler 

	// that can process this command.

	return ETrue;

	}

TInt CL2CapLinkSignalHandler::ConstructEchoRequest(const TDes8* aData, MEchoResponseHandler& aEchoResponseHandler)

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	HEchoRequest* command = NULL;

	if(aData)

		{

		RMBufChain data;

		TRAP(rerr, data.CreateL(*aData));

		if(rerr == KErrNone)

			{

			command = HEchoRequest::New(data, CurrentRTXTimerDuration(HL2CapCommand::KDefaultRTXTimerDuration));

			}

		}

	else

		{

		command = HEchoRequest::New();

		}

	if(rerr == KErrNone)

		{

		if(command)

			{

			command->SetEchoResponseHandler(aEchoResponseHandler);

			AddToOutgoingQueue(command);

			}

		else

			{

			rerr = KErrNoMemory;

			}

		}

	return rerr;

	}

void CL2CapLinkSignalHandler::DeregisterOutstandingEchoRequests(MEchoResponseHandler& aEchoResponseHandler)

	{

	LOG_FUNC

	// Find any Echo Request and if the calling reference matches set

	// it to NULL.

	HL2CapCommand* l2CapCommand;

	TDblQueIter<HL2CapCommand> iter(iCommandsAwaitingResponse);

	while((l2CapCommand = iter++) != NULL)

		{

		if(l2CapCommand->Code() == EEchoRequest)

			{

			HEchoRequest* request = static_cast<HEchoRequest*>(l2CapCommand);

			if(request->EchoResponseHandler() == &aEchoResponseHandler)

				{

				// Found a matching request - there can only be one so stop searching.

				request->RemoveEchoResponseHandler();

				break;

				}

			}

		}

	}

TBool CL2CapLinkSignalHandler::HandleEchoResponse(HEchoResponse* aEchoResponse)

	{

	LOG_FUNC

	// Check that the Echo Response has been requested.

	HL2CapCommand* requestCommand = FindMatchingOutstandingRequest(EEchoRequest, aEchoResponse->ID());

	if(requestCommand)

		{

		HEchoRequest* request = static_cast<HEchoRequest*>(requestCommand);

		if(request->EchoResponseHandler())

			{

			RMBufChain data;

			HBufC8* echoDataBuf = NULL;

			if(aEchoResponse->GetData(data) == KErrNone)

				{

				echoDataBuf = HBufC8::New(data.Length());	

				if(echoDataBuf)

					{		

					const TDes8& bufc = echoDataBuf->Des();

					TDes8& echoData = const_cast<TDes8&>(bufc);

					echoData.SetMax();

					data.CopyOut(echoData);

					}

				data.Free();

				}

			iMuxer->EchoResponseReceived(echoDataBuf, *request->EchoResponseHandler());

			}

		// Delete the request.

		delete requestCommand;

		}

	// If the response does not have an outstanding request drop

	// the command silently.  Always return true, this command

	// can only be for the link signal handler.

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleEchoRequest(HEchoRequest* aEchoRequest) //Incoming

	{

	LOG_FUNC

	//1. Create a Echo Response Command

	HL2CapCommand* command = HEchoResponse::New(aEchoRequest->ID());

	//2. Add to the list of outgoing commands

	if(command)

		{

		AddToOutgoingQueue(command);

		}

	return ETrue;

	}	

TInt CL2CapLinkSignalHandler::ConstructInformationRequest(TInfoType aInfoType)

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	//1. Create a ConnectionRequest Command

	HL2CapCommand* command = HInformationRequest::New(aInfoType, CurrentRTXTimerDuration(HL2CapCommand::KDefaultRTXTimerDuration));

	if(command)

		{

		AddToOutgoingQueue(command);

		}

	else

		{

		rerr = KErrNoMemory;

		}

	return rerr;

	}	

TBool CL2CapLinkSignalHandler::HandleInformationRequest(HInformationRequest* aInformationRequest)

	{

	LOG_FUNC

	// The peer is requesting the L2CAP entities capabilities.

	switch(aInformationRequest->InfoType())

		{

		case EExtendedFeaturesSupported:

			{

			TUint32 extendedFeatures = KL2CAPExtendedFeaturesSupported;

			HL2CapCommand* command = HInformationResponse::New(EExtendedFeaturesSupported, ESuccess, aInformationRequest->ID(), extendedFeatures);

			if(command)

				{

				// Add to the list of outgoing commands

				AddToOutgoingQueue(command);	

				}

			// If the command could not be created the connection will fail in the

			// signalling state machine.

			break;

			}

		// If the info requested is Connectionless MTU or a info type that

		// is not recognised, return a response with result code 'not supported'.

		case EConnectionlessMTU:

		default:

			{

			//Return InfoType and Not supported

			HL2CapCommand* command = HInformationResponse::New(aInformationRequest->InfoType(), 

			                                                   ENotsupported, 

			                                                   aInformationRequest->ID());

			if(command)

				{

				// Add to the list of outgoing commands

				AddToOutgoingQueue(command);	

				}

			// If the command could not be created the connection will fail in the

			// signalling state machine.

			break;

			}

		};

	//This should not occur as it should be handled by derived classes. 

	return(ETrue);

	}

TBool CL2CapLinkSignalHandler::HandleInformationResponse(HInformationResponse* aInformationResponse)

	{

	LOG_FUNC

	// Check that the Information Response has been requested.

	HL2CapCommand* requestCommand = FindMatchingOutstandingRequest(EInformationRequest, aInformationResponse->ID());

	if(requestCommand)

		{

		HInformationRequest* req = static_cast<HInformationRequest*>(requestCommand);

		// The Info Type in the response should match that in the 

		// request.

		if(req->InfoType() == aInformationResponse->InfoType())

			{

			switch(aInformationResponse->InfoType())

				{

				case EExtendedFeaturesSupported:

					if(aInformationResponse->Result() == ESuccess)

						{

						iPeerL2CapEntityConfig.UpdatePeerL2CapSupportedFeatures(aInformationResponse->RemoteExtendedFeatureMask());

						}

					else

						{

						// The result was a failure.  Set the supported

						// features to the default of not supported.

						iPeerL2CapEntityConfig.UpdatePeerL2CapSupportedFeatures(TL2CapEntityInfo());

						}

					iMuxer->L2CapEntityConfigUpdated();

					break;

				default:

					break;

				};

			}

		else

			{

			// The request and response info types don't match.  If the request

			// was for extended features, [for the sake of interop] assume that

			// no extended features are supported by the peer device.

			if(req->InfoType() == EExtendedFeaturesSupported)

				{

				iPeerL2CapEntityConfig.UpdatePeerL2CapSupportedFeatures(TL2CapEntityInfo());

				iMuxer->L2CapEntityConfigUpdated();

				}

			}

		// Delete the request.

		delete requestCommand;

		}

	// If the response does not have an outstanding request drop

	// the command silently.  Always return true, this command

	// can only be for the link signal handler.

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleCommandReject(HCommandReject* aCommandReject)

	{

	LOG_FUNC

	// Process the incoming command reject data

	TL2CAPCommandRejectData rejectData;

	if (aCommandReject->RejectData(rejectData) != KErrNone) 

		{

		LOG(_L("CL2CapLinkSignalHandler::HandleCommandReject - reject data could not be parsed"));

		// Couldn't parse the reject data, but we've got no-one to

		// pass handling this on to, so we have to say we've processed

		// it.

		return ETrue;

		}

	LOG1(_L("CL2CapLinkSignalHandler::HandleCommandReject - reject data: reason %d"), rejectData.iReason);

	switch(rejectData.iReason)

		{

		case ECommandNotUnderstood:

			{

			// The peer does not recognise a command we have sent.

			// Check if the outstanding request is causing the issue.

			HL2CapCommand* requestCommand = FindMatchingOutstandingRequest(EMatchAnyL2CAPRequest, aCommandReject->ID());

			if(requestCommand)

				{

				// This is a work around to allow the new stack to interop with

				// stacks that send Command Reject in response to Information Request.

				if(requestCommand->Code() == EInformationRequest)

					{

					// Set the supported features to the default of not supported.

					iPeerL2CapEntityConfig.UpdatePeerL2CapSupportedFeatures(TL2CapEntityInfo());

					iMuxer->L2CapEntityConfigUpdated();

					}

				delete requestCommand;

				}

			}

			break;

		case EMTUExceeded:

			iSigMTU = Max(rejectData.iMTUExceeded, KL2MinMTU);

			break;

		case EInvalidCID:

			// This handles a corner case where a Disconnect Request command 

			// retransmission crosses over with the Response for the initial

			// Disconnect Request.  The peer will correctly send a Command Reject

			// for the second Disconnect Request.  This should be ignored. 

			break;

		default:

			break;

		};

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleInvalidCommand(HInvalidCommand* aInvalidCommand)

	{

	LOG_FUNC

	TL2CAPCommandRejectData reason;

	reason.iReason = ECommandNotUnderstood;

	// Other reject data fields are not used for Command Not Understood

	reason.iMTUExceeded = 0;

	reason.iLocalEndpoint = 0;

	reason.iRemoteEndpoint = 0;

	HL2CapCommand* command = HCommandReject::New(reason, aInvalidCommand->ID());

	if(command)

		{

		AddToOutgoingQueue(command);

		}

	// The link signal handler always services invalid commands.

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleConnectionResponse(HConnectionResponse* /*aConnectionResponse*/)

	{

	LOG_FUNC

	// This command has not been handled by any of the SAP 

	// signal handlers. It's a response so just drop it.

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleConfigureRequest(HConfigureRequest* aConfigRequest)

	{

	LOG_FUNC

	// This command has not been handled by any of the SAP 

	// signal handlers.  Send a Command Reject.

	SendInvalidCIDCommandReject(aConfigRequest->ID(),

	                            0,

                                aConfigRequest->DestinationCID());

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleConfigureResponse(HConfigureResponse* /*aConfigResponse*/)	

	{

	LOG_FUNC

	// This command has not been handled by any of the SAP 

	// signal handlers. It's a response so just drop it.

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleDisconnectRequest(HDisconnectRequest* aDisconnectRequest)	

	{

	LOG_FUNC

	// This command has not been handled by any of the SAP 

	// signal handlers.  Send a Command Reject.

	SendInvalidCIDCommandReject(aDisconnectRequest->ID(),

	                            aDisconnectRequest->SourceCID(),

                                aDisconnectRequest->DestinationCID());

	return ETrue;

	}

TBool CL2CapLinkSignalHandler::HandleDisconnectResponse(HDisconnectResponse* /*aDisconnectResponse*/)	

	{

	LOG_FUNC

	// This command has not been handled by any of the SAP 

	// signal handlers. It's a response so just drop it.

	return ETrue;

	}

void CL2CapLinkSignalHandler::PendingCommandsDrained()

	{

	LOG_FUNC

	// No action is required here.

	}

// HIncomingSAPSigPDUHandler Interface Definition.

void CL2CapLinkSignalHandler::LinkUp()

	{

	LOG_FUNC

	// No action required from the LinkSignalHandler when the link is established.

	}

void CL2CapLinkSignalHandler::Error(TInt /*aErrorCode*/, MSocketNotify::TOperationBitmasks /*aErrorAction*/)

	{

	LOG_FUNC

	HandleLinkError();

	}

void CL2CapLinkSignalHandler::CommandResponseFailure(HL2CapCommand* aCommand)

	{

	LOG_FUNC

	switch(aCommand->Code())