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

// Rfcomm muxer

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include "rfcommmuxer.h"

#include "rfcomm.h"

#include "rfcommutil.h"

#include "rfcommframe.h"

#include "rfcommtypes.h"

#include "rfcommfcs.h"

#include "rfcommsap.h"

#include "rfcommflow.h"

#include "rfcommmuxchannel.h"

#include "AsyncErrorKicker.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_RFCOMM);

#endif

// Disable int to char warnings

#ifdef __WINS__

#pragma warning( disable : 4244 )

#endif

#ifdef __FLOG_ACTIVE

_LIT(KCommandText, "command");

_LIT(KResponseText, "response");

#endif //__FLOG_ACTIVE

const TUint8 KBitsForNumberInTInt = 32 - 1; // -1 is because we don't count the sign bit

CRfcommMuxer* CRfcommMuxer::NewL(CRfcommProtocol& aProt, CProtocolBase& aL2CAP,

								CMuxChannelStateFactory& aFactory)

	/**

	Factory function for CRfcommMuxer - called when local device initiates the connection.

	Note the CProtocolBase passed in so that the muxer can create its own L2CAP SAP

	**/

	{

	CRfcommMuxer* mux= new (ELeave) CRfcommMuxer(aProt,KInitiationDirectionOutgoing);

	CleanupStack::PushL(mux);

	mux->ConstructL(aFactory, aL2CAP);

	CleanupStack::Pop();

	return mux;

	}

CRfcommMuxer* CRfcommMuxer::NewL(CRfcommProtocol& aProt, CServProviderBase* aSAP,

								CMuxChannelStateFactory& aFactory)

	/**

	Factory function for CRfcommMuxer - called when remote device initiates the connection.

	Note the CServProviderBase passed in, which becomes the L2CAP SAP used by this muxer.

	@param aSAP		 This is a connected L2CAP sap

	@param aFactory  The Mux channel state factory

	@return          A new Muxer in the right state

	**/

	{

	CRfcommMuxer* mux= new (ELeave) CRfcommMuxer(aProt,KInitiationDirectionIncoming);

	CleanupStack::PushL(mux);

	mux->ConstructL(aFactory, aSAP);

	CleanupStack::Pop();

	return mux;

	}

CRfcommMuxer::CRfcommMuxer(CRfcommProtocol& aProt, TInitiationDirection aDirection)

	: iSAPs(_FOFF(CRfcommSAP, iLink)),

	  iOutboundQ(_FOFF(CRfcommFrame, iLink)),

	  iResponseQ(_FOFF(CRfcommFrame, iLink)),

	  iOutboundQLength(0),

	  iProtocol(aProt),

	  iDirection(aDirection),

	  iMuxIdleTimeout(KRfcommMuxIdleTimeoutOpening),	  

	  iCanSend(ETrue),

	  iBlockedSAPs(_FOFF(CRfcommSAP, iLink)),

	  iDataFramesSent(0),

	  iL2CAPSendBlocked(EFalse),

	  iTriedCBFC(EFalse),

	  iCurrentCredit(0),

	  iInitialTxCredit(0),

	  iFlowStrategy(0)

	{

	TCallBack cb(IdleTimerExpired, this);

	iIdleTimerEntry.Set(cb);

	}

void CRfcommMuxer::ConstructL(CMuxChannelStateFactory& aFactory, CProtocolBase& aL2CAP)

	{ 

	// Create a SAP for this to use

	iBoundSAP=aL2CAP.NewSAPL(KSockSeqPacket);

	iMuxChannel = new (ELeave) CRfcommMuxChannel(aFactory, *this, *iBoundSAP, CMuxChannelStateFactory::EClosed);

	//	We now have a bound L2Cap SAP.

	//  Use it to setup L2Cap config for RFComm.

	TL2CapConfigPkg configPkg;

	iProtocol.SetL2CapConfig(configPkg);

	User::LeaveIfError(iBoundSAP->SetOption(KSolBtL2CAP, KL2CAPUpdateChannelConfig, configPkg));

	CommonConstructL();

	}

void CRfcommMuxer::ConstructL(CMuxChannelStateFactory& aFactory, CServProviderBase* aSAP)

	{ 

	// SAP has been provided for this to use, so start it

	__ASSERT_DEBUG(aSAP!=NULL, Panic(ERfcommNullSAPForMuxer));

	iBoundSAP=aSAP;

	iBoundSAP->Start();

	TBTSockAddr btAddr;

	aSAP->RemName(btAddr);

	iRemoteAddr=btAddr.BTAddr();

	iMuxChannel = new (ELeave) CRfcommMuxChannel(aFactory, *this, *iBoundSAP, CMuxChannelStateFactory::ELinkUp);

	CommonConstructL();

	}

void CRfcommMuxer::CommonConstructL()

	{

	iBoundSAP->SetNotify(this);

	TCallBack cb(TryToSendCallbackStatic,this);

	iSendCallback=new (ELeave) CAsyncCallBack(cb, ECAsyncImmediatePriority);

	iNextPacket=HBufC8::NewL(KRfcommDefaultMTU);  // This will do for now

#ifdef NO_CBFC

	iFlowStrategy = TRfcommFlowStrategyNonCreditBased::NewL(*this);

#else

	if(iProtocol.CBFCDisallowed())

		{

		SetFlowType(CRfcommFlowStrategyFactory::EFlowNonCreditBased);

		iTriedCBFC = ETrue;

		}

	else

		{

		SetFlowType(CRfcommFlowStrategyFactory::EFlowInitial);

		}

#endif

	}

CRfcommMuxer::~CRfcommMuxer()

	{

	LOG(_L("CRfcommMuxer::~CRfcommMuxer"));

	DequeIdleTimer();

	DeleteQueuedFrames();

	// remove the references to this muxer in any SAPs it is/was linked to

	TDblQueIter<CRfcommSAP> iter(iSAPs);

	CRfcommSAP* sap;

	while(iter)

		{

		sap=iter++;

		if (sap)

			{

			sap->iMux = NULL;

			sap->iLink.Deque();

			}

		}

	delete iSendCallback;

	delete iBoundSAP;

	delete iNextPacket;

	delete iMuxChannel;

	}

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

/*

  Commands from the protocol.

*/

void CRfcommMuxer::Bind(TBTDevAddr& aAddr)

	/**

	   Bind this mux to the given remote address

	   Calling this function implies that this end is to be the

	   initiator (direction bit = 1).  The bound sap will be used to

	   create an L2CAP link to the remote end over which the RFCOMM

	   frames will flow.  The muxchannel will then run this channel.

	**/

	{

	iRemoteAddr=aAddr;

	iMuxChannel->SetAddress(aAddr);

	}

void CRfcommMuxer::AddSAP(CRfcommSAP& aSAP)

	/**

	   Adds a sap to the Q for this mux.

	**/

	{

	DequeIdleTimer();

	iSAPs.AddFirst(aSAP);

	if(iMuxChannel->IsOpen())

		aSAP.MuxUp();

	else

		iMuxChannel->Open();  // Eventually calls back

	}

void CRfcommMuxer::DetachSAP(CRfcommSAP& aSAP)

	/**

	   Detach this sap.

	   If it's the last one, shut down.  We clean out the outbound and

	   response queues as we no longer want these frames since the sap

	   has gone.

	**/

	{

	aSAP.iLink.Deque();

	aSAP.iMux=0;

	ClearOutboundQueue(aSAP);

	ClearResponseQueue(aSAP);

	CheckForIdle(ETrue);

	}

void CRfcommMuxer::GetInboundServerChannelsInUse(TFixedArray<TBool, KMaxRfcommServerChannel>& aChannelInUse)

	/**

	   Identify inbound server channels in use for connected SAPs.

	   aChannelInUse is an array indexed by (server channel - 1) and on return 

	   aChannelInUse will be updated with any inbound server channels that

	   are currently in use by connected SAPs.

	**/

	{

	TDblQueIter<CRfcommSAP> iter(iSAPs);

	CRfcommSAP* sap;

	// Only interested in cloned SAPs as this identifies if the SAP is for 

	// an inbound connection

	while(iter)

		{

		sap=iter++;		

		if (sap->IsCloned())

			{

			aChannelInUse[sap->ServerChannel() - 1] = ETrue;

			}

		}

	iter=iBlockedSAPs;

	while(iter)

		{

		sap=iter++;

		if (sap->IsCloned())

			{

			aChannelInUse[sap->ServerChannel() - 1] = ETrue;

			}

		}	

	}

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

/*

  Notifications from the MSocketNotify interface

*/

void CRfcommMuxer::NewData(TUint aCount)

	/**

	   Called when new data is available.

	   This is called each time a new packet of data arrives from L2CAP.

	   We get to the data by calling GetData on the SAP.

	   Frames never span a L2CAP packet, and are one per packet.

	   This assumes a packet interface from L2CAP

	   @param aCount  Number of new packets waiting

	**/

	{

 	if (aCount == KNewDataEndofData)

 		{

		LOG(_L("RFCOMM: L2CAP signalled EndOfData"));

 		Disconnect();

 		}

	else

		{

		LOG1(_L("RFCOMM: New data, count %d"), aCount);

		//BLOG: KBlogNewData

		iPacketsWaiting+=aCount;

		while(CanProcessNewData() && iPacketsWaiting)

			{

			// Get a packet into the buffer

			TPtr8 data=iNextPacket->Des();

			data.SetMax();

			iBoundSAP->GetData(data, 0);

			// process the new data

			ProcessFrame();

			iPacketsWaiting--;

			}

		}

	}

void CRfcommMuxer::CanSend()

	/**

	   Notification that we can now send data to the lower layer.

	**/

	{

	L2CAPBlocked(EFalse);

	TryToSend();

	}

//CBFC

CRfcommFlowStrategyFactory::TFlowStrategies CRfcommMuxer::FlowType()

	{

	return iFlowStrategy->FlowType();

	}

#ifdef NO_CBFC

TBool CRfcommMuxer::FlowType(CRfcommFlowStrategyFactory::TFlowStrategies /*aFlow*/)

	{

	return EFalse;

	}

#else

TBool CRfcommMuxer::SetFlowType(CRfcommFlowStrategyFactory::TFlowStrategies aFlow)

	{

	if(iTriedCBFC)

		{

		LOG(_L("RFCOMM: Requesting new flow strategy again: DISALLOWED"));

		return EFalse;

		}

	switch(aFlow)

		{

	case CRfcommFlowStrategyFactory::EFlowCreditBased:

		LOG(_L("RFCOMM: Requesting CBFC at SAP level"));

		iTriedCBFC = ETrue;				// stop the test being done again

		iFlowStrategy = &(iProtocol.FlowStrategyFactory()->GetFlowStrategy(aFlow));

		break;

	case CRfcommFlowStrategyFactory::EFlowNonCreditBased:

		LOG(_L("RFCOMM: Not requesting CBFC at SAP level"));

		iTriedCBFC = ETrue;				// stop the test being done again

		iFlowStrategy = &(iProtocol.FlowStrategyFactory()->GetFlowStrategy(aFlow));

		break;

	default:

		iFlowStrategy = &(iProtocol.FlowStrategyFactory()->GetFlowStrategy(CRfcommFlowStrategyFactory::EFlowInitial));

		break;

		}

	return ETrue;

	}

#endif

void CRfcommMuxer::DisallowCBFC()

	{

	iCBFCDisallowed = ETrue;

	}

void CRfcommMuxer::AllowCBFC()

	{

	iCBFCDisallowed = EFalse;

	}

TRfcommFlowStrategy* CRfcommMuxer::FlowStrategy()

	{

	return iFlowStrategy;

	}

void CRfcommMuxer::ConnectComplete(const TDesC8& /*aConnectData*/)

	/**

	   Version with connection data.

	   Ignore the data (since L2CAP should never provide this!)

	**/

	{

	ConnectComplete();

	}

void CRfcommMuxer::ConnectComplete(CServProviderBase& /*aSSP*/)

	/**

	   Incoming connection completed on listen socket.

	**/

	{

	Panic(ERfcommIncomingNotSupported);

	}

void CRfcommMuxer::ConnectComplete(CServProviderBase& /*aSSP*/,const TDesC8& /*aConnectData*/)

	{

	Panic(ERfcommIncomingNotSupported);

	}

void CRfcommMuxer::CanClose(TDelete /*aDelete*/)

	/**

	   We must have asked the socket to shutdown, which means we're dying.

	**/

	{

	LOG1(_L("RFCOMM: CanClose from L2CAP for mux %08x"), this);

	iMuxChannel->CanClose();

	}

void CRfcommMuxer::CanClose(const TDesC8& /*aDisconnectData*/,TDelete /*aDelete*/)

	{

	Panic(ERfcommDisconnectDataNotSupported);

	}

void CRfcommMuxer::Error(TInt aError,TUint aOperationMask)

	/**

	   Something's gone wrong.

	   We get told whether it's just this operation or all that are

	   affected, but we'll just assume that all of them are bust for

	   now.

	**/

	{

	LOG1(_L("RFCOMM: Error on L2CAP sap %d"), aError);

	if(aOperationMask & MSocketNotify::EErrorIoctl)

		{

		// This was an ioctl problem, so pass up to the saps

		PropagateIoctlCompletion(aError, iIoctlLevel, iIoctlName, NULL);

		iIoctlName=0;

		iIoctlLevel=0;

		}

	// Pass this on to the Mux channel as well

	iMuxChannel->Error(aError, aOperationMask);

	}

void CRfcommMuxer::MuxChannelError(TBool aFatal, TInt aError)

	/**

	   Something's gone wrong on the mux channel

	   If this is a fatal error it means we need a new muxchannel,

	   else we can live with it.  Either way we need to error all the

	   existing saps.

	**/

	{

	LOG1(_L("RFCOMM: Error on Mux %d"), aError)

	TDblQueIter<CRfcommSAP> iter(iSAPs);

	CRfcommSAP* sap;

	// Erroring the saps will remove them from us when we signal a 

	// general error

	while(iter)

		{

		sap=iter++;

		sap->Error(aError, CRfcommSAP::EErrorGeneral);

		}

	iter=iBlockedSAPs;

	while(iter)

		{

		sap=iter++;

		sap->Error(aError, CRfcommSAP::EErrorGeneral);

		}

	if(aFatal)

		{

		// The channel is now useless, and so is the mux

		// Set the address to 0 to stop any more saps attaching

		DeleteQueuedFrames();

		iRemoteAddr=TInt64(0);

		return;

		}

	CheckForIdle(ETrue);

	}

const TBTDevAddr& CRfcommMuxer::RemoteBTAddr() const

	{

	return iRemoteAddr;

	}

void CRfcommMuxer::MuxChannelDown()

	/**

	   The mux channel has gone down.

	   Pass this on to the saps	

	**/

	{

	CloseSAPs();

	DeleteQueuedFrames(); // since we can't send or receive any more

	CheckForIdle(ETrue);

	}

void CRfcommMuxer::CloseSAPs()

	{

	TDblQueIter<CRfcommSAP> iter(iSAPs);

	CRfcommSAP* sap;

	while(iter)

		{

		sap=iter++;

		sap->LinkDown();

		}

	iter=iBlockedSAPs;

	while(iter)

		{

		sap=iter++;

		sap->LinkDown();

		}

	}

void CRfcommMuxer::MuxChannelUp()

	/**

	   The mux channel has come up.

	   We need to allocate the buffer for incoming packets.  Note this

	   may not be the same as the RFCOMM MTU since we can't guarantee

	   that the other end won't send us omore in an L2CAP packet.

	**/

	{

	TPckgBuf<TInt> buf;