// Copyright (c) 1999-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:

// Implement the L2CAP sap state classes.

// These are CL2CAPSAPStateFactory, TL2CAPSAPState (abstract) and its derived

// classes

// Together, these classes and the SAP implement the State pattern

// (GOF).  The states themselves are implemented using the Flyweight

// pattern.  Each state is a Flyweight object, and CL2CAPSAPStateFactory

// is manager of these objects.  As a result of being a flyweight, no

// state object may have state that can't be shared between all

// possible users of the state (ie no per-SAP state)

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include "l2sapstates.h"

#include "L2CapSDUQueue.h"

#include "L2CapDataController.h"

#include "l2capSAPSignalHandler.h"

#include "l2sap.h"

#include "l2cap.h"

#include "l2util.h"

#ifdef _DEBUG

#include "L2CapDebugControlInterface.h"

#endif

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);

#endif

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

//

// TL2CAPSAPState Implementation

//

TL2CAPSAPState::TL2CAPSAPState(CL2CAPSAPStateFactory& aFactory)

: iFactory(aFactory)

	{

	LOG_FUNC

	}

void TL2CAPSAPState::PanicInState(TL2CAPPanic aPanic) const

	{

	LOG_FUNC

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

	}

#ifdef _DEBUG

void TL2CAPSAPState::DebugPanicInState(TL2CAPPanic aPanic) const

#else

void TL2CAPSAPState::DebugPanicInState(TL2CAPPanic /*aPanic*/) const

#endif

	{

	LOG_FUNC

	#ifdef _DEBUG

	PanicInState(aPanic);

	#endif

	}

void TL2CAPSAPState::StartCalledWhileDisconnected(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// This function is intended to be called (under some circumstances when a Start()

	// has been received. This handles the case where in between the Start() call and

	// the construction of the cloned SAP on which the Start is being made, the link

	// which prompted the cloning has disconnected.  Therefore, if we are a cloned sap

	// and have been "coupled" with an client side socket we need to inform it of the

	// disconnection.

	if(aSAP.ListeningSAP())

		{

		if(aSAP.Socket())

			{

			if(aSAP.SocketErrorCode() == KErrNone)

				{

				aSAP.Socket()->Disconnect();

				}

			else

				{

				aSAP.Socket()->Error(aSAP.SocketErrorCode(), aSAP.SocketErrorAction());

				}

			}

		// We also need to take ourselves off the listening SAP's 'clone' queue, just 

		// as we do in the fair weather case when Start is called in state 'Accepting'.

		aSAP.DetachFromListeningSAP();

		}

	}

// DEFAULT Implementations

// Socket Initiated.

void TL2CAPSAPState::Start(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

TInt TL2CAPSAPState::Ioctl(CL2CAPConnectionSAP& /*aSAP*/, TUint /*aLevel*/, TUint /*aName*/, TDes8* /*aOption*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	return KErrSAPUnexpectedEvent;

	}

void TL2CAPSAPState::CancelIoctl(CL2CAPConnectionSAP& /*aSAP*/, TUint /*aLevel*/, TUint /*aName*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

void TL2CAPSAPState::IoctlComplete(CL2CAPConnectionSAP& /*aSAP*/, TInt /*aErr*/, TUint /*aLevel*/, TUint /*aName*/, TDesC8* /*aBuf*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

void TL2CAPSAPState::ActiveOpen(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

TInt TL2CAPSAPState::PassiveOpen(CL2CAPConnectionSAP& /*aSAP*/, TUint /*aQueSize*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	return KErrSAPUnexpectedEvent;

	}

void TL2CAPSAPState::Shutdown(CL2CAPConnectionSAP& /* aSAP */) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

void TL2CAPSAPState::FastShutdown(CL2CAPConnectionSAP& /* aSAP */) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

TInt TL2CAPSAPState::Send(CL2CAPConnectionSAP& /*aSAP*/, RMBufChain& /*aData*/, TUint /*aFlag*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	return KErrNotReady; // Indicate that no data has been sent.

	}

TInt TL2CAPSAPState::Read(CL2CAPConnectionSAP& /*aSAP*/, RMBufChain& /*aData*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	return KErrNotReady;

	}

void TL2CAPSAPState::Bound(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSocketEvent);

	}

// Events called from the SAP Signal Handler.

void TL2CAPSAPState::ChannelConfigured(CL2CAPConnectionSAP& /*aSAP*/,

	                                   CL2CapChannelConfig& /*aConfig*/,

                                       CL2CAPMux& /*aMuxer*/,

                                       TL2CAPPort /*aLocalPort*/,

                                       TL2CAPPort /*aRemotePort*/)

	{

	LOG_FUNC

	DebugPanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}

void TL2CAPSAPState::ReconfiguringChannel(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	DebugPanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}

void TL2CAPSAPState::ChannelClosed(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}

void TL2CAPSAPState::CloseOutgoingSDUQueue(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}	

void TL2CAPSAPState::SignalHandlerError(CL2CAPConnectionSAP& /*aSAP*/, TInt /*aErrorCode*/, MSocketNotify::TOperationBitmasks /*aErrorAction*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}	

void TL2CAPSAPState::LinkUp(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}	

void TL2CAPSAPState::ChannelOpened(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSAPSignalHandlerEvent);

	}	

// Events called from the Data Controller.

void TL2CAPSAPState::NewData(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedDataControllerEvent);

	}

TInt TL2CAPSAPState::NewDataAsyncCallBack(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedDataControllerEvent);

	//Need to return something to stop error in compiler

	return(KErrNone);

	}

void TL2CAPSAPState::CanSend(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedDataControllerEvent);

	}

void TL2CAPSAPState::SDUQueueClosed(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedDataControllerEvent);

	}

void TL2CAPSAPState::DataPlaneError(CL2CAPConnectionSAP& /*aSAP*/, TInt /*aErrorCode*/, MSocketNotify::TOperationBitmasks /*aErrorAction*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedDataControllerEvent);

	}

// Events from the security manager.

void TL2CAPSAPState::AccessRequestComplete(CL2CAPConnectionSAP& /*aSignalHandler*/, TInt /*aResult*/) const

	{

	LOG_FUNC

	PanicInState(EL2CAPUnexpectedSecurityManagerEvent);

	}

// State Transition Actions.

void TL2CAPSAPState::Enter(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	}

void TL2CAPSAPState::Exit(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	}

// Helper method.

void TL2CAPSAPState::NotifySocketClosed(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// Enter the closed state.

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EClosed));

	// Check if this is owned by the socket yet.  If it is the socket needs

	// to be notified, and is responsible for deleting this SAP.

	if(aSAP.Socket())

		{

		switch(aSAP.ShutdownReceived())

			{

			case CL2CAPConnectionSAP::ESAPShutdownNormal:

				aSAP.Socket()->CanClose();

				break;

			case CL2CAPConnectionSAP::ESAPShutdownNone:

				if(aSAP.SocketErrorCode() == KErrNone)

					{

					aSAP.Socket()->Disconnect();

					}

				else

					{

					// An error has occurred, enter the error state.

					aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EError));

					aSAP.Socket()->Error(aSAP.SocketErrorCode(), aSAP.SocketErrorAction());

					}

				break;

			case CL2CAPConnectionSAP::ESAPShutdownImmediate:

				break;

			default:

				PanicInState(EL2CAPInvalidSAPShutdownType);

				break;	

			};

		}

	else

		{

		if(!aSAP.IsAcceptPending())

			{

			// This is not owned by a socket - delete it.

			aSAP.DetachFromListeningSAP();

			aSAP.DeleteSAP();

			}

		}

	}

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

//

// TL2CAPSAPStateClosed Implementation

//

TL2CAPSAPStateClosed::TL2CAPSAPStateClosed(CL2CAPSAPStateFactory& aFactory)

 : TL2CAPSAPState(aFactory)

 	{

	LOG_FUNC

 	}

// Events called from the SAP.

void TL2CAPSAPStateClosed::Start(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// If a passive connection was established and then disconnected by the peer

	// the Start notification will be received in this state.

	// This is handled in the Closed state rather than in the Bound state since

	// we're not bound from the stack's point of view in this situation.

	StartCalledWhileDisconnected(aSAP);

	}

void TL2CAPSAPStateClosed::ActiveOpen(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EActiveLinkPending));

	// If there is a Service set for CodMan, register it.

	aSAP.RegisterCodService();

	TInt rerr = aSAP.Protocol().MuxController().AttachActiveSignalHandler(aSAP.SignalHandler(), aSAP.RemoteDev());

	if(rerr != KErrNone)

		{

		// Set up an error condition to indicate that the connection

		// has failed.

		aSAP.SetSocketErrorCode(KErrCouldNotConnect);

		aSAP.SetSocketErrorAction(MSocketNotify::EErrorConnect);

		NotifySocketClosed(aSAP);	

		}

	}

void TL2CAPSAPStateClosed::SDUQueueClosed(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	// Nothing needs to be done here.  FastShutdown scenario.

	}

// Events called from the SAP Signal Handler.

void TL2CAPSAPStateClosed::ChannelClosed(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	// Ignore in this state.  This will be due to a fast shutdown.

	}

void TL2CAPSAPStateClosed::SignalHandlerError(CL2CAPConnectionSAP& /*aSAP*/, TInt /*aErrorCode*/, MSocketNotify::TOperationBitmasks /*aErrorAction*/) const

	{

	LOG_FUNC

	// Ignore in this state.  This will be due to a fast shutdown.

	}	

void TL2CAPSAPStateClosed::Enter(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	aSAP.iNewDataToNotify = 0;	

	aSAP.DeregisterCodService();	// See if there is a Service to remove for CodMan

	}

void TL2CAPSAPStateClosed::FastShutdown(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	// Shutdown is permitted by ESOCK on an open (not connected) socket.

	// Therefore this must be handled in the closed or bound state.

	// No action required here.

	}

void TL2CAPSAPStateClosed::Shutdown(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// Shutdown is permitted by ESOCK on an open (not connected) socket.

	// Therefore this must be handled in the closed or bound state.

	aSAP.Socket()->CanClose();

	}

void TL2CAPSAPStateClosed::Bound(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EBound));

	}

TInt TL2CAPSAPStateClosed::NewDataAsyncCallBack(CL2CAPConnectionSAP& /*aSAP*/) const

	{

	LOG_FUNC

	//drop

	return EFalse;

	}

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

//

// TL2CAPSAPStateChannelPendingBase Implementation

//

TL2CAPSAPStateChannelPendingBase::TL2CAPSAPStateChannelPendingBase(CL2CAPSAPStateFactory& aFactory)

 : TL2CAPSAPState(aFactory)

 	{

	LOG_FUNC

 	}

// Events called from the SAP Signal Handler.

void TL2CAPSAPStateChannelPendingBase::SignalHandlerError(CL2CAPConnectionSAP& aSAP, TInt aErrorCode, MSocketNotify::TOperationBitmasks aErrorAction) const

	{

	LOG_FUNC

	// Store the error information.

	aSAP.SetSocketErrorCode(aErrorCode);

	aSAP.SetSocketErrorAction(aErrorAction);

	NotifySocketClosed(aSAP);	

	}

void TL2CAPSAPStateChannelPendingBase::ChannelClosed(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// Set up an error condition to indicate that the connection

	// has failed.

	aSAP.SetSocketErrorCode(KErrCouldNotConnect);

	aSAP.SetSocketErrorAction(MSocketNotify::EErrorConnect);

	NotifySocketClosed(aSAP);	

	}

// Events called from the SAP.

void TL2CAPSAPStateChannelPendingBase::Shutdown(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// Enter the disconnecting state and disconnect the Mux.

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EDisconnecting));

	aSAP.SignalHandler().CloseChannelRequest();

	}

void TL2CAPSAPStateChannelPendingBase::FastShutdown(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// Enter the closed state and disconnect the Mux.

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EClosed));

	aSAP.SignalHandler().CloseChannelRequest();

	}

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

//

// TL2CAPSAPStatePassiveLinkPending Implementation

//

TL2CAPSAPStatePassiveLinkPending::TL2CAPSAPStatePassiveLinkPending(CL2CAPSAPStateFactory& aFactory)

 : TL2CAPSAPStateChannelPendingBase(aFactory)

 	{

	LOG_FUNC

 	}

void TL2CAPSAPStatePassiveLinkPending::LinkUp(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// Forward the Connect Request event to the signalling state machine.

	aSAP.SignalHandler().ConnectRequestReceived();

	// Start security checks.

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EPassiveAccessRequestPending));

	aSAP.StartAccessRequest(*(aSAP.ListeningSAP()));

	}

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

//

// TL2CAPSAPStateActiveLinkPending Implementation

//

TL2CAPSAPStateActiveLinkPending::TL2CAPSAPStateActiveLinkPending(CL2CAPSAPStateFactory& aFactory)

 : TL2CAPSAPStateChannelPendingBase(aFactory)

 	{

	LOG_FUNC

 	}

void TL2CAPSAPStateActiveLinkPending::LinkUp(CL2CAPConnectionSAP& aSAP) const

	{

	LOG_FUNC

	// This is the first call to StartAccessRequest() for v2.1 clients.

	// For outgoing requests, we perform authentication both before the L2CAP

	// connection is started, and immediately after (for compatibility with

	// pre 2.1 clients). Here, we just set the required MITM settings; this

	// has no effect on pre-2.1 clients but this will succeed for 2.1 clients

	// and the subsequent call is effectively a null-operation.

	aSAP.SetState(iFactory.GetState(CL2CAPSAPStateFactory::EActiveSecMode4AccessRequestPending));

	aSAP.StartAccessRequest(aSAP, ETrue); // indicate that this is outgiong security mode 4

	}

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

//

// TL2CAPSAPStateActiveSecMode4AccessRequestPending Implementation

//

TL2CAPSAPStateActiveSecMode4AccessRequestPending::TL2CAPSAPStateActiveSecMode4AccessRequestPending(CL2CAPSAPStateFactory& aFactory)

: TL2CAPSAPStateChannelPendingBase(aFactory)

	{

	LOG_FUNC

	}

// Events called from the SAP.

void TL2CAPSAPStateActiveSecMode4AccessRequestPending::FastShutdown(CL2CAPConnectionSAP& aSAP) const

	{