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

//

// Implements the signalling state machine for an L2Cap Channel

#include <bluetooth/logger.h>

#include "l2capSAPSignalHandler.h"

#include "l2capSigStates.h"

#include "l2capSigPacketConnection.h"

#include "l2capSigPacketConfigure.h"

#include "l2capSigPacketDisconnection.h"

#include "l2capSigPacketEcho.h"

#include "l2capSigPacketCommandReject.h"

#include "l2capSigStates.h"

#include "l2signalmgr.h"

#include "l2capSAPSignalHandler.h"

#include "l2cap.h"

#include "l2sap.h"

#include "l2util.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);

#endif

/*************************************************************************/

//

// TL2CAPSigState Implementation

// 

TL2CAPSigState::TL2CAPSigState(const CL2CAPSignalStateFactory& aFactory):

	iFactory(aFactory)

	{

	LOG_FUNC

	}

// Events from the SAP

void TL2CAPSigState::CloseChannel(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	// This is a standard action for most states.

	// Disconnect received from the SAP.  Return to the

	// closed state.

	aSignalHandler.HandleLinkError();

	aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EClosed));

	// Signal back to the SAP that disconnection is complete.

	aSignalHandler.SAP()->ChannelClosed();

	}

void TL2CAPSigState::OpenChannel(CL2CapSAPSignalHandler& /*aSignalHandler*/) const	

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPEvent);

	}

void TL2CAPSigState::ConnectRequestReceived(CL2CapSAPSignalHandler& /*aSignalHandler*/) const	

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPEvent);

	}

void TL2CAPSigState::ConfigureChannel(CL2CapSAPSignalHandler& /*aSignalHandler*/) const	

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPEvent);

	}

// L2CAP commands received from the peer.

void TL2CAPSigState::ConnectResponse(CL2CapSAPSignalHandler& /*aSignalHandler*/,

						 			 HConnectionResponse* /*aConnectionResponse*/) const

	{

	LOG_FUNC

	LOG1(_L("Unhandled Connect Response, state = 0x%08x"), this);

	}

void TL2CAPSigState::ConfigRequest(CL2CapSAPSignalHandler& /*aSignalHandler*/,

										  HConfigureRequest* /*aConfigRequest*/) const

	{

	LOG_FUNC

	LOG1(_L("Unhandled Config Req, state = 0x%08x"), this);

	}

void TL2CAPSigState::ConfigResponse(CL2CapSAPSignalHandler& /*aSignalHandler*/,

 	                					   HConfigureResponse* /*aConfigResponse*/) const

	{

	LOG_FUNC

	LOG1(_L("Unhandled Config Response, state = 0x%08x"), this);

	}

void TL2CAPSigState::DisconnectRequest(CL2CapSAPSignalHandler& /*aSignalHandler*/, 

                                              TUint8 /*aId*/) const

	{

	LOG_FUNC

	LOG1(_L("Unhandled Disconnect Request, state = 0x%08x"), this);

	}

void TL2CAPSigState::DisconnectResponse(CL2CapSAPSignalHandler& /*aSignalHandler*/) const

	{

	LOG_FUNC

	LOG1(_L("Unhandled Disconnect Response, state = 0x%08x"), this);

	}

// Events from the Mux	

void TL2CAPSigState::Error(CL2CapSAPSignalHandler& aSignalHandler,

	                       TInt aErrorCode, 

	                       MSocketNotify::TOperationBitmasks aErrorAction) const

	{

	LOG_FUNC

	// An error has occurred in the Mux or the signal handler.  This means no

	// more signalling can be done.  Move to the closed state.  Signal link down

	// to clear any pending commands and stop waiting for outstanding responses.

	// Inform the SAP of the error.

	aSignalHandler.HandleLinkError();

	aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EClosed));

	// This will delete the signal handler if the SAP has detached.

	aSignalHandler.SignalHandlerErrorD(aErrorCode, aErrorAction);

	}

TInt TL2CAPSigState::UpdateChannelConfig(CL2CapSAPSignalHandler& aSignalHandler, const TL2CapConfig& aAPIConfig) const

	{

	LOG_FUNC

	// The default action is to update the values.  Different actions are taken

	// if configuration is in progress or the channel is open.

	TBool reconfigRequired; //  this only matters when the channel is already Open, can ignore it here

	return aSignalHandler.ChannelConfig().UpdateConfigAPIChange(aAPIConfig, reconfigRequired);

	}

TInt TL2CAPSigState::GetNegotiatedChannelMode(const CL2CapSAPSignalHandler& /*aSignalHandler*/, TL2CapChannelMode& /*aMode*/) const

	{

	return KErrNotReady;

	}

// Change of state events

void TL2CAPSigState::Enter(CL2CapSAPSignalHandler& /*aSignalHandler*/) const

	{

	LOG_FUNC

	}

void TL2CAPSigState::Exit(CL2CapSAPSignalHandler& /*aSignalHandler*/) const

	{

	LOG_FUNC

	}	

// Signal command queue event

void TL2CAPSigState::PendingCommandsDrained(CL2CapSAPSignalHandler& /*aSignalHandler*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}

// Timers

void TL2CAPSigState::ConfigurationTimerExpiry(CL2CapSAPSignalHandler& /*aSignalHandler*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}

// Helpers		

TBool TL2CAPSigState::IsChannelClosed() const

	{

	LOG_FUNC

	// Default is false.  Only true in closed state.

	return EFalse;

	}

TBool TL2CAPSigState::IsChannelOpen() const

	{

	// Only true in Open state.

	return EFalse;

	}

void TL2CAPSigState::HandleDisconnectRequest(CL2CapSAPSignalHandler& aSignalHandler, TUint8 aId) const

	{

	LOG_FUNC

	aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitDisconnect));

	TInt err = aSignalHandler.ConstructDisconnectResponse(aId);

	if(err == KErrNone)

		{

		aSignalHandler.DrainPendingCommands();

		}

	else

		{

		// Failed to send the response.  Go directly into the closed state

		// and inform the SAP that disconnection is complete.

		aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EClosed));

		aSignalHandler.HandleLinkError();

		aSignalHandler.SAP()->ChannelClosed();

		}

	}

void TL2CAPSigState::HandleSAPDisconnect(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	TInt err = KErrDisconnected;

	if(aSignalHandler.RemotePort() != 0)

		{

		// We have a remote CID from a response with result pending, issue a disconnect request

		aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitDisconnect));

		err = aSignalHandler.ConstructDisconnectRequest();

		}	

	if(err != KErrNone)

		{

		// Failed to send the request or do not have a connection (without a valid CID). 

		// Go directly into the closed state and inform the SAP that disconnection is complete.

		aSignalHandler.HandleLinkError();

		aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EClosed));

		aSignalHandler.SAP()->ChannelClosed();

		}

	}

TInt TL2CAPSigState::SendConfigRequest(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	return aSignalHandler.ConstructConfigRequest();

	}

TInt TL2CAPSigState::SendConfigResponse(CL2CapSAPSignalHandler& aSignalHandler, TConfigResponseResult aResult) const

	{

	LOG_FUNC

	return aSignalHandler.ConstructConfigResponse(aSignalHandler.GetOutstandingRequestID(), 

	                                              HConfigureResponse::KNoConfigurationFlags,

	                                              aResult);

	}

void TL2CAPSigState::DisconnectWithError(CL2CapSAPSignalHandler& aSignalHandler, TInt aError) const

	{

	aSignalHandler.SetSignalHandlerErrorCode(aError);

	aSignalHandler.SetSignalHandlerErrorAction(MSocketNotify::EErrorAllOperations);

	aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitDisconnect));

	TInt err = aSignalHandler.ConstructDisconnectRequest();

	if(err != KErrNone)

		{

		// Failed to send the request. Call the Error method, this

		// will move the state to closed and forward the error to

		// the SAP.

		Error(aSignalHandler, aError, MSocketNotify::EErrorAllOperations);

		}

	}

/**

Calls the appropriate panic function to encode the panic

code with the current state identifier.

@param aPanic The panic code that the state is panicking with.

*/

void TL2CAPSigState::PanicInState(TL2CAPPanic aPanic) const

	{

	LOG_FUNC

	Panic(aPanic, iFactory.StateIndex(this));

	}

/*************************************************************************/

// Implementation of TL2CAPStateClosed

//

// Starting state and state re-entered when L2Cap logical link has been disconnected.

//

TL2CAPSigStateClosed::TL2CAPSigStateClosed(const CL2CAPSignalStateFactory& aFactory)

	: TL2CAPSigState(aFactory)

	{

	LOG_FUNC

	}

void TL2CAPSigStateClosed::OpenChannel(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	// The SAP has requested a channel be opened.

	TInt err = aSignalHandler.ChannelConfig().UpdateLocalConfigWithEntityCapabilities();

	if (err == KErrNone)

		{

		// Get a free source CID for this channel to use.

		TL2CAPPort port;

		err = aSignalHandler.Mux().GetFreeCID(port);

		if(err == KErrNone)

			{

			// Update local Port.

			aSignalHandler.SetLocalPort(port);

			// Active connection.  Send a Connect Request command.

			err = aSignalHandler.ConstructConnectionRequest();

			if(err == KErrNone)

				{

				aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitConnectRsp));

				}

			}

		}

	if (err != KErrNone)

		{

		// The L2CAP connection could not be initiated.  Error the SAP.

		Error(aSignalHandler, err, MSocketNotify::EErrorConnect);

		}

	}

void TL2CAPSigStateClosed::ConnectRequestReceived(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	TInt err = KErrNone;

	// An ACL has been established.

	// Get a free source CID for this channel to use.

	TL2CAPPort port;

	err = aSignalHandler.Mux().GetFreeCID(port);

	if(err == KErrNone)

		{

		// Update local Port.

		aSignalHandler.SetLocalPort(port);

		// Send a response with a 'pending' result and start security procedure.

		err = aSignalHandler.ConstructConnectionResponse(aSignalHandler.GetOutstandingRequestID(),

	                                                     EConnectPending,

		                                                 EConnectPendAuthorization);

		}

	if(err == KErrNone)

		{

		aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitConnect));

		}

	else

		{

		// The L2CAP connection could not be initiated.  Error the SAP.

		Error(aSignalHandler, err, MSocketNotify::EErrorConnect);

		}

	}

void TL2CAPSigStateClosed::CloseChannel(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	// Detach from the Mux.  Inform the SAP that disconnection is complete.

	aSignalHandler.DetachFromMux();

	aSignalHandler.SAP()->ChannelClosed();

	}

void TL2CAPSigStateClosed::ConfigRequest(CL2CapSAPSignalHandler& aSignalHandler,

								  		 HConfigureRequest* aConfigRequest) const

	{

	LOG_FUNC

	aSignalHandler.SendInvalidCIDCommandReject(aConfigRequest->ID(),

											   0,

											   aConfigRequest->DestinationCID());

	}

TBool TL2CAPSigStateClosed::IsChannelClosed() const

	{

	LOG_FUNC

	return ETrue;

	}

void TL2CAPSigStateClosed::Enter(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	// Cancel the configuration timer.

	aSignalHandler.CancelTimer();

	aSignalHandler.iOpenChannelRequestAwaitingPeerEntityConfig = EFalse;

	aSignalHandler.UndoOverrideParkMode();

	// If the signal handler has left the closed state, it will have been added

	// to the SH list in the Muxer.  Now that the closed state is being

	// re-entered, remove the handler from the Muxer queue.

	// NB It is safe to call this method multiple times.

	aSignalHandler.DetachFromMux();

	}

/************************************************************/

// Implementation of void TL2CAPSigStateWaitConnectRsp

//

// This represents an Active SAP that is waiting for a connection response

TL2CAPSigStateWaitConnectRsp::TL2CAPSigStateWaitConnectRsp(const CL2CAPSignalStateFactory& aFactory)

	: TL2CAPSigState(aFactory)

	{

	LOG_FUNC

	}

// L2CAP commands received from the peer.

void TL2CAPSigStateWaitConnectRsp::ConnectResponse(CL2CapSAPSignalHandler& aSignalHandler,

								 				   HConnectionResponse* aConnectionResponse) const

	{

	LOG_FUNC	

	switch(aConnectionResponse->Result())

		{

		case EConnectSuccess:

			aSignalHandler.SetRemotePort(aConnectionResponse->DestinationCID());

			aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitConfig));

			aSignalHandler.SAP()->ChannelOpened();

			break;

		case EConnectPending:

			aSignalHandler.SetRemotePort(aConnectionResponse->DestinationCID());

			break;	// No other action here - the ERTx timer has been started.

		default:

			// One of the failed, non-pending results

			// The connect has failed

			// We're re-connectable, so go back to orig state

			// NB Error now clears muxer and sets state to closed

			Error(aSignalHandler, ((aConnectionResponse->Result() == EConnectSecurityBlock) ? KErrL2CAPAccessRequestDenied : KErrCouldNotConnect), MSocketNotify::EErrorConnect);

			break;

		};

	}

void TL2CAPSigStateWaitConnectRsp::ConfigRequest(CL2CapSAPSignalHandler& /*aSignalHandler*/,

						 						 HConfigureRequest* /*aConfigRequest*/) const

	{

	LOG_FUNC

	// Override the default panicing action for this state as we may validly be

	// here.  This could happen if the remote has sent a connect response, followed

	// by this config request but we have not successfully processed the connect 

	// response.  This can happen when the response arrives after the rtx has

	// expired but we haven't yet resent the connect request.

	}

// Events from the Mux

void TL2CAPSigStateWaitConnectRsp::CloseChannel(CL2CapSAPSignalHandler& aSignalHandler) const

	{	

	// Disconnect the channel.	

	HandleSAPDisconnect(aSignalHandler);

	}

void TL2CAPSigStateWaitConnectRsp::Enter(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	//set the remote CID to 0

	aSignalHandler.SetRemotePort(TL2CAPPort(0));

	aSignalHandler.iAwaitConfigureChannelRequest = ETrue;

	}

/****************************************************************************/

// 

// Waiting for the SAP to indicate that the connection can be established.

TL2CAPSigStateWaitConnect::TL2CAPSigStateWaitConnect(const CL2CAPSignalStateFactory& aFactory)

	: TL2CAPSigState(aFactory)

	{

	LOG_FUNC

	}

// Events from the SAP

void TL2CAPSigStateWaitConnect::OpenChannel(CL2CapSAPSignalHandler& aSignalHandler) const

	{

	LOG_FUNC

	TInt updateConfigErr = aSignalHandler.ChannelConfig().UpdateLocalConfigWithEntityCapabilities();

	TInt sendErr = KErrNone;

	if (updateConfigErr == KErrNone)

		{

		// The connection has been allowed.  Send the connection response.

		sendErr = aSignalHandler.ConstructConnectionResponse(aSignalHandler.GetOutstandingRequestID(),

															 EConnectSuccess,

															 EConnectPendNoFurtherInfo);

		if (sendErr == KErrNone)

			{

			// Enter the initial config state and initiate local configuration.

			aSignalHandler.SetState(iFactory.GetState(CL2CAPSignalStateFactory::EWaitConfig));

			if(!aSignalHandler.DelayConfigRequest())

				// We should never get in here! The timer, which allows the delay

				// should have been started on entry to the state "WaitConfig". 

				{

				aSignalHandler.ConfigureChannel();

				}

			}

		} // Success Response

	else

		{

		// We don't have a generic 'Just no' response code, 'No resources' comes closest.

		sendErr = aSignalHandler.ConstructConnectionResponse(aSignalHandler.GetOutstandingRequestID(),

														     EConnectNoResources,

															 EConnectPendNoFurtherInfo);

		if (sendErr == KErrNone)

			{

			// When the response is sent, PendingCommandsDrained() will call Error().

			aSignalHandler.SetSignalHandlerErrorCode(updateConfigErr);

			aSignalHandler.SetSignalHandlerErrorAction(MSocketNotify::EErrorConnect);

			aSignalHandler.DrainPendingCommands();

			}

		} // Failure response

	if (sendErr != KErrNone)

		{

		// The L2CAP connection could not be initiated.  Error the SAP.

		Error(aSignalHandler, sendErr, MSocketNotify::EErrorConnect);

		}

	}

// Events from the Mux