// 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 <bt_sock.h>

#include "rfcommstates.h"

#include "rfcomm.h"

#include "rfcommmuxer.h"

#include "rfcommflow.h"

#include "rfcommconsts.h"

#include "AsyncErrorKicker.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_RFCOMM);

#endif

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

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

CRfcommStateFactory* CRfcommStateFactory::NewL()

	/**

	   Create all the state singletons.

	**/

	{

	CRfcommStateFactory* factory= new (ELeave) CRfcommStateFactory();

	CleanupStack::PushL(factory);

	// Create all the new states

	factory->ConstructL();

	CleanupStack::Pop();

	return factory;

	}

void CRfcommStateFactory::ConstructL()

	{

	iStates[EError]  = new (ELeave) TRfcommStateError(*this);

	iStates[EClosed] = new (ELeave) TRfcommStateClosed(*this);

	iStates[EWaitForMux]= new (ELeave) TRfcommStateWaitForMux(*this);

	iStates[EWaitForPNResp]= new (ELeave) TRfcommStateWaitForPNResp(*this);

	iStates[EWaitForUA]= new (ELeave) TRfcommStateWaitForUA(*this);

	iStates[EOpen]      = new (ELeave) TRfcommStateOpen(*this);

	iStates[EDisconnect]      = new (ELeave) TRfcommStateDisconnect(*this);

	iStates[EListening] = new (ELeave) TRfcommStateListening(*this);

	iStates[EWaitForSABM] = new (ELeave) TRfcommStateWaitForSABM(*this);

	iStates[EWaitForIncomingSecurityCheck] = new (ELeave) TRfcommStateIncomingSecurityCheck(*this);

	iStates[EWaitForOutgoingSecurityCheck] = new (ELeave) TRfcommStateOutgoingSecurityCheck(*this);

	iStates[EWaitForStart] = new (ELeave) TRfcommStateWaitForStart(*this);

	iStates[ECloseOnStart] = new (ELeave) TRfcommStateCloseOnStart(*this);

	iStates[EDisconnecting] = new (ELeave) TRfcommStateDisconnecting(*this);

	// etc...

	}

TInt CRfcommStateFactory::StateIndex(const TRfcommState* aState) const

	{

	TInt state;

	for (state = 0; state < ERfcommMaxState; state++)

		{

		if (iStates[state] == aState)

			{

			return state;

			}

		}

	return KUnknownState;

	}

/*

TRfcommState base class implementation

*/

TInt TRfcommState::SignalError(CRfcommSAP& aSAP, TInt aErr, MSocketNotify::TOperationBitmasks aType)

	/**

	   Signal an error, with appropriate types to tell socket what's

	   been affected.

	**/

	{

	if (aSAP.iSocket)

		{

		aSAP.iSocket->Error(aErr, aType);

		}

	if(aType & MSocketNotify::EErrorFatal)

		{

		ChangeState(aSAP, CRfcommStateFactory::EError);

		}

	return aErr;

	}

// State change utility function

void TRfcommState::ChangeState(CRfcommSAP& aSAP, CRfcommStateFactory::TRfcommStates aNewState) const

	{

	aSAP.iState->Exit(aSAP);

#ifdef __FLOG_ACTIVE

	TRfcommState* state= iFactory.GetState(aNewState);

	LOG3(_L("RFCOMM : Sap %08x : State %S -> %S"),

				  &aSAP, &aSAP.iState->iName, &state->iName);

#endif //__FLOG_ACTIVE

	aSAP.iState=iFactory.GetState(aNewState);

	aSAP.iState->Enter(aSAP);

	}

void TRfcommState::PanicInState(TRFCOMMPanic aPanic) const

	{

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

	}

#ifdef _DEBUG

void TRfcommState::DebugPanicInState(TRFCOMMPanic aPanic) const

#else

void TRfcommState::DebugPanicInState(TRFCOMMPanic /*aPanic*/) const

#endif

	{

	#ifdef _DEBUG

	PanicInState(aPanic);

	#endif

	}

TRfcommState::TRfcommState(CRfcommStateFactory& aFactory)

	: iFactory(aFactory)

	{

	}

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

/*

   The default state operations.

*/

TRfcommStateDefault::TRfcommStateDefault(CRfcommStateFactory& aFactory)

	: TRfcommState(aFactory)

	{

	}

void TRfcommStateDefault::Enter(CRfcommSAP& /*aSAP*/)

	{

	// Do nothing

	}

void TRfcommStateDefault::Exit(CRfcommSAP& /*aSAP*/)

	{

	// Do nothing

	}

void TRfcommStateDefault::ActiveOpen(CRfcommSAP& /* aSAP */ )

	{

	PanicInState(ERfcommUnexpectedEvent);

	}

TInt TRfcommStateDefault::PassiveOpen(CRfcommSAP& /* aSAP */,

									  TUint /*aQueSize*/)

	{

	PanicInState(ERfcommUnexpectedEvent);

	return KErrGeneral;

	}

void TRfcommStateDefault::Shutdown(CRfcommSAP& aSAP)

	{

	SignalError(aSAP, KErrRfcommSAPUnexpectedEvent, MSocketNotify::EErrorAllOperations);

	}

void TRfcommStateDefault::FastShutdown(CRfcommSAP& aSAP)

	{

	SignalError(aSAP, KErrRfcommSAPUnexpectedEvent, MSocketNotify::EErrorAllOperations);

	}

TInt TRfcommStateDefault::Send(CRfcommSAP& /*aSAP*/, const TDesC8& /*aData*/ )

	{

	PanicInState(ERfcommUnexpectedEvent);

	return 0;

	}

void TRfcommStateDefault::Read(CRfcommSAP& /*aSAP*/, TDesC8& /*aData*/)

	{

	PanicInState(ERfcommUnexpectedEvent);

	}

void TRfcommStateDefault::Ioctl(CRfcommSAP& aSAP, TUint /*aLevel*/,

								TUint /*aName*/, TDes8* /*aOption*/)

	{

	SignalError(aSAP, KErrNotSupported, MSocketNotify::EErrorIoctl);

	}

void TRfcommStateDefault::CancelIoctl(CRfcommSAP& aSAP, TUint /*aLevel*/, TUint /*aName*/)

	/**

	   A request to cancel an Ioctl.

	   Since the user has already been completed, and ESOCK prevents

	   the completion occuring twice, there's very little we need to

	   do (in fact we could ignore this entirely).

	   Instead we will simply reset out IoctlLevel and IoctlName,

	   since this will now mean that we will not complete the ioctl

	   when the complete signal comes in.  If the ioctl is going on

	   below us, we will ignore the ioctl complete from them as well.

	**/

 	{

	aSAP.iIoctlLevel=0;

	aSAP.iIoctlName=0;

 	}

void TRfcommStateDefault::Start(CRfcommSAP& /*aSAP*/)

	{

	PanicInState(ERfcommUnexpectedEvent);

	}

TInt TRfcommStateDefault::SetOption(CRfcommSAP &aSAP, TUint aLevel, 

								   TUint aName, const TDesC8& aOption)

	/**

	   Set Option from user - works the same for SAPs in all states.

	**/

	{

	if(aLevel == KSolBtRFCOMM)

		{

		switch(aName)

			{

		case KRFCOMMLocalPortParameter:

			// Just do a straight copy into the local port params

			aSAP.iLocalPortParams = *(TRfcommRemotePortParams*)aOption.Ptr();

			break;

		case KRFCOMMMaximumSupportedMTU:

    		{

			if ( aOption.Length() != sizeof(TUint16) )

				{

				return KErrArgument;

				}

			else

				{

				TPckgBuf<TUint16> maxMTU;

				maxMTU.Copy(aOption);

				aSAP.iUserDefinedMTU = maxMTU();

				}

			};

			break;

		case KRFCOMMFlowTypeCBFC:

			{

			if ( aOption.Length() != sizeof(TBool) )

				{

				return KErrArgument;

				}

			else

				{

				TPckgBuf<TBool> aCBFC;

				aCBFC.Copy(aOption);

				if(!aCBFC())

					{

					//Switch off CBFC facility by setting flow strategy to

					//non-CBFC and setting the flow negotiated flag to 'ETrue'.

					if(aSAP.iMux)

						{

						if(!aSAP.iMux->SetFlowType(CRfcommFlowStrategyFactory::EFlowNonCreditBased))

							{

							return KErrNotSupported;

							}

						}

					else

						{

						aSAP.DisallowCBFC(); //will cause muxer to use muxwise CBFC when created

						}

					}

				else

					{

					//Switch on CBFC facility by setting flow strategy to

					//CBFC and setting the flow negotiated flag to 'ETrue'.

					if(aSAP.iMux)

						{

						if(!aSAP.iMux->SetFlowType(CRfcommFlowStrategyFactory::EFlowCreditBased))

							{

							return KErrNotSupported;

							}

						}

					else

						{

						aSAP.AllowCBFC(); //will cause muxer to use muxwise CBFC when created

						}

					}

				}

			}

			break;

		case KRFCOMMErrOnMSC:

			{

			if ( aOption.Length() != sizeof(TUint8) )

				{

				return KErrArgument;

				}

			else

				{

				TPckgBuf<TUint8> aSignal;

				aSignal.Copy(aOption);

				aSAP.iDisconnectMSCSignal = aSignal();

				}

			}

			break;

		case KBTSecurityDeviceOverride:

			{

			// let the security object handle this

			return aSAP.SetDeviceOverride(aOption); // just pass the option

			}

		case KBTRegisterCodService:

			{

			TInt err = KErrNone;

	        TUint16 newServiceBits = *reinterpret_cast<const TUint16*>(aOption.Ptr());

			err = aSAP.SetCodServiceBits(newServiceBits);	// The service bits are saved and then registered when SAP becomes live

			return err;

			}

		case KRFCOMMForgiveCBFCOverflow:

    		{

			if ( aOption.Length() != sizeof(TBool) )

				{

				return KErrArgument;

				}

			else

				{

				aSAP.iForgiveCBFCOverflow = *reinterpret_cast<const TBool*>(aOption.Ptr());

				}

			};

			break;

		default:

			return KErrNotSupported;

			}

		return KErrNone;

		}

	// Not a RFCOMM setopt so error.  We don't support passdown (yet).

	return KErrNotSupported;	

	}

void TRfcommStateDefault::MuxUp(CRfcommSAP& aSAP)

	{

	SignalError(aSAP, KErrRfcommSAPUnexpectedEvent,

				MSocketNotify::EErrorAllOperations);

	}

void TRfcommStateDefault::LinkDown(CRfcommSAP& aSAP)

	{

	SignalError(aSAP, KErrRfcommSAPUnexpectedEvent,

				MSocketNotify::EErrorAllOperations);

	}

void TRfcommStateDefault::SABM(CRfcommSAP& /*aSAP*/, CRfcommMuxer& aMux, TUint8 aDLCI)

	/**

	   Send a DM, since we are not expecting this

	**/

	{

	aMux.SendDM(aDLCI);

	}

void TRfcommStateDefault::DISC(CRfcommSAP& aSAP)

	/**

	   Send a DM as we were not expecting this

	**/

	{

	aSAP.iMux->SendDM(aSAP.iDLCI);

	}

void TRfcommStateDefault::UA(CRfcommSAP& /*aSAP*/)

	/**

	   Do nothing - unexpected response

	**/

	{

	}

void TRfcommStateDefault::DM(CRfcommSAP& /*aSAP*/)

	/**

	   Do nothing - unexpected response

	**/

	{

	}

void TRfcommStateDefault::RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& /*aRPNTransaction*/, CRfcommMuxer& /*aMuxer*/, TUint8 /*aDLCI*/)

	/**

	   Send a DM as we didn't expect this

	**/

 	{

	aSAP.iMux->SendDM(aSAP.iDLCI);

 	}

void TRfcommStateDefault::RPNRsp(CRfcommSAP& /*aSAP*/, 

								const TRfcommRPNTransaction& 

								/*aRPNTransaction*/)

	/**

	   Do nothing - unwanted response

	**/

 	{

 	}

void TRfcommStateDefault::PN(CRfcommSAP& aSAP, TRfcommPortParams& /*aParams*/, CRfcommMuxer& /*aMux*/, TUint8 aDLCI)

	/**

	   Send a DM as we aren't handling this.

	**/

	{

	__ASSERT_DEBUG(aDLCI==aSAP.iDLCI, PanicInState(ERfcommPNMismatchedDLCI));

	aSAP.iMux->SendDM(aDLCI);

	}

void TRfcommStateDefault::PNResp(CRfcommSAP& /*aSAP*/, TRfcommPortParams& /*aParams*/)

	/**

	   Do nothing - unwanted response

	**/

	{

	}

void TRfcommStateDefault::MSC(CRfcommSAP& /*aSAP*/, TUint8 /*aSignals*/)

	/**

	   Do nothing - the response is autogenerated

	**/

	{

	}

void TRfcommStateDefault::RLS(CRfcommSAP& /*aSAP*/, TUint8 /*aStatus*/)

	/**

	   Do nothing - the response is autogenerated

	**/

 	{

 	}

void TRfcommStateDefault::NewData(CRfcommSAP& /*aSAP*/, const TDesC8& /*aData*/)

	/**

	   Do nothing - we're throwing this data away

	**/

	{

	}

void TRfcommStateDefault::NotifyNewDataCallback(CRfcommSAP& aSAP)

	{

	SignalError(aSAP, KErrRfcommSAPUnexpectedEvent, MSocketNotify::EErrorAllOperations);

	}

void TRfcommStateDefault::CanSend(CRfcommSAP& aSAP)

	{

	SignalError(aSAP, KErrRfcommSAPUnexpectedEvent, MSocketNotify::EErrorAllOperations);

	}

void TRfcommStateDefault::IoctlComplete(CRfcommSAP& /*aSAP*/, TInt /*aErr*/, TUint /*aLevel*/, TUint /*aName*/, TDesC8* /*aBuf*/)

	{

	// Do nothing, this isn't for us

	}

void TRfcommStateDefault::AccessRequestComplete(CRfcommSAP& /*aSAP*/, TInt /*aResult*/)

	{

	PanicInState(ERfcommUnexpectedSecurityRequesterCallback);

	}

void TRfcommStateDefault::Error(CRfcommSAP& aSAP, TInt aErr,

								CRfcommSAP::TErrorTypes /*aType*/)

	{

	SignalError(aSAP, aErr,

				MSocketNotify::EErrorAllOperations);

	}

void TRfcommStateDefault::ParentClosed(CRfcommSAP& aSAP)

	/**

	Our parent SAP has been deleted - NULL our pointer to it.

	This function only really applies to cloned child SAPs, but we

	handle it here anyway.

	**/

	{

	aSAP.iParentSAP=NULL;

	}

TBool TRfcommStateDefault::HandleFrameResponseTimeout(CRfcommSAP& /*aSAP*/)

	{

	//	By default, we refuse to handle the frame timeout, indicating this by

	//	returning EFalse.

	return EFalse;

	}

//TRY_CBFC

TUint8 TRfcommStateDefault::FreeCredit(CRfcommSAP& /*aSAP*/)

	{

	// return the max initial credit

	return (TUint8)KInitialCredit;

	}

TInt TRfcommStateDefault::ProxyForRemoteCredit(const CRfcommSAP& /*aSAP*/) const

	{

	// return the max initial credit

	return (TInt)KInitialCredit;

	}

void TRfcommStateDefault::SetProxyForRemoteCredit(CRfcommSAP& aSAP, TInt aCredit)

	{

	aSAP.iProxyForRemoteCredit = aCredit;

	LOG1(_L("RFCOMM: Proxy for credits available on REMOTE (...NEW SETUP...) -> %d"), aSAP.iProxyForRemoteCredit);

	}

void TRfcommStateDefault::ProxyForRemoteCreditDecrement(CRfcommSAP& aSAP)

	{

	__ASSERT_DEBUG(aSAP.iProxyForRemoteCredit > 0,PanicInState(ERfcommCBFCProxyForRemoteCreditGoingNegative));

	aSAP.iProxyForRemoteCredit--;

	LOG(_L("RFCOMM: Proxies for CREDITS on REMOTE:-"));

	LOG2(_L("RFCOMM:     Available for use  (...DECREMENT...) %d -> %d: -1"), 

				  aSAP.iProxyForRemoteCredit+1,

				  aSAP.iProxyForRemoteCredit);

	#ifdef _DEBUG

	aSAP.iProxyForRemoteCreditsUsed++;

	LOG1(_L("RFCOMM:     Total USED so far during this session: %d"), 

				  aSAP.iProxyForRemoteCreditsUsed);

	#endif

	return;