// Copyright (c) 2003-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 avdtp signalling channel

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include "avdtpSignallingChannel.h"

#include "avdtp.h"

#include "avdtputil.h"

#include "avdtpSignallingTransaction.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);

#endif

//Macro to just return (and enter debugger in debug builds) if we get an unsolicited response packet

#define RETURN_IF_NO_TRANSACTION(transaction) 	if (!transaction) {	LOG(_L("No transaction found"));return;}

#define RETURN_IF_SIGNAL_BAD(transaction, signal) if (!CheckSignal(*transaction, signal)) {LOG1(_L("Transaction has different signal (%d)"), signal); return;}

// check that sessions have replied with an AVDTP error in error cases

#define	CHECK_ERROR(result) if (!(result<=KErrAvdtpSignallingErrorBase || result==KErrNone || result==KErrNotFound)) __DEBUGGER();

CSignallingChannel* CSignallingChannel::NewL(CAvdtpProtocol& aProtocol,

											 CLogicalChannelFactory& aChannelFactory,

											 const TBTDevAddr& aRemoteAddress)

	{

	LOG_STATIC_FUNC

	CSignallingChannel* s = CSignallingChannel::NewLC(aProtocol, aChannelFactory, aRemoteAddress);

	CleanupStack::Pop();

	return s;

	}

CSignallingChannel* CSignallingChannel::NewLC(CAvdtpProtocol& aProtocol,

											  CLogicalChannelFactory& aChannelFactory,

											  const TBTDevAddr& aRemoteAddress)

	{

	LOG_STATIC_FUNC

	CSignallingChannel* s = new(ELeave)	CSignallingChannel(aProtocol, aChannelFactory, aRemoteAddress);

	CleanupStack::PushL(s);

	s->ConstructL();

	return s;

	}

CSignallingChannel::CSignallingChannel(CAvdtpProtocol& aProtocol,

									   CLogicalChannelFactory& aChannelFactory,

									   const TBTDevAddr& aRemoteAddress)

: iProtocol(aProtocol),

  iLogicalChannelFactory(aChannelFactory),

  iPermanentUsers(_FOFF(XAvdtpSignalReceiver,iSignalReceiverEmbeddedLink)),

  iTransactions(_FOFF(CSignallingTransaction,iLink)),

  iRemoteAddress(aRemoteAddress),

  iInboundMessage(*this),

  iDraftMessages(_FOFF(CAvdtpOutboundSignallingMessage,iLink)),

  iQueuedMessages(_FOFF(CAvdtpOutboundSignallingMessage,iLink))

	{

	LOG_FUNC

	SetBlocked(EFalse);

	TCallBack cb(TryToClose, this);

	iIdleTimerEntry.Set(cb);

	}

void CSignallingChannel::ConstructL()

	{

	LOG_FUNC

	TCallBack cb(CSignallingChannel::TryToSendCallback, this);

	iTryToSendCallback = new (ELeave)CAsyncCallBack(cb, CActive::EPriorityStandard);

	}

CSignallingChannel::~CSignallingChannel()

	{

	LOG_FUNC

	CancelIdleTimer();

	// cancel possible outstanding factory request

	iLogicalChannelFactory.Cancel(iLogicalChannelRequest);

	// remove from protocol's knowledge

	iProtocol.SignallingChannelDown(*this);

	// any preauthorisation for device this represents is now void

	if (!IsListening())

		{

		iProtocol.RemoteSEPCache().InvalidateSEPs(iRemoteAddress);

		(void)iProtocol.SetPreauthorisation(iRemoteAddress, EFalse);

		}

	if (iBearer)

		{

		// tell l2cap

		iBearer->Shutdown(CServProviderBase::EImmediate);

		}

	delete iBearer;

	delete iTryToSendCallback;

	}

void CSignallingChannel::StartTryToSendCallback()

	{

	LOG_FUNC

	if (!iTryToSendCallback->IsActive())

		{

		iTryToSendCallback->CallBack();

		}

	// else already running and will callback anyway

	}

void CSignallingChannel::CancelTryToSendCallback()

	{

	LOG_FUNC

	iTryToSendCallback->Cancel();

	}

/*static*/ TInt CSignallingChannel::TryToSendCallback(TAny *aSigCh)

	{

	LOG_STATIC_FUNC

	return (reinterpret_cast<CSignallingChannel*>(aSigCh))->TryToSendCallback();

	}

void CSignallingChannel::ObtainMTU()

	{

	LOG_FUNC

	TPckg<TInt> mtubuf(iBearerMTU);

	TInt err=iBearer->GetOption(KSolBtL2CAP,KL2CAPOutboundMTUForBestPerformance,mtubuf);

	if (err!=KErrNone)

		{

		Error(err);

		}

	}

/*

Does post-packet-send processing

*/

void CSignallingChannel::PacketSent(CSignallingTransaction& aTransaction)

	{

	LOG_FUNC

	// We can't delete the transaction yet, because it looks after timer.

	switch (aTransaction.SentAction())

		{

		case EKeepSetRTX:

			{

			aTransaction.StartTimer();

			break;

			}

		case EDiscard:

			{

			// these transactions can be cleared up now

			// we don't support caching of responses if they get lost - they'll be regenerated if needed

			aTransaction.iLink.Deque();

			delete &aTransaction;

			break;

			}

		case EKeepDontSetRTX:

		// do nothing!

			break;

		default:

			__ASSERT_DEBUG(0, Panic(EAvdtpUnknownPostSendAction));

		}

	}

void CSignallingChannel::CheckOutboundQueue()

	{

	// check to see if the outbound queue is empty but we have an outstanding

	// request to service it

	if (iQueuedMessages.IsEmpty() && iTryToSendCallback->IsActive())

		{

		CancelTryToSendCallback();

		}				

	}

void CSignallingChannel::ServiceOutboundQueue()

	{

	LOG_FUNC

	if (!Blocked())

		{

		// we can send!

		// get fragments to send if we don't have any from before

		if(iOutgoingSignallingMessage.IsEmpty())

			{

			// get the head message

			CAvdtpOutboundSignallingMessage& message = *iQueuedMessages.First();

			// find the transaction pertaining to it (and make it the current transaction)

			iCurrentTransaction = FindTransaction(message.TransactionLabel());

			__ASSERT_DEBUG(iCurrentTransaction!=NULL, Panic(EAvdtpSignallingChannelDrainingFaulty));

			// see whether this requires fragmenting, and get next fragment

			// note reference return parameter

			TRAPD(ret, iMoreFrags = message.GetNextOutboundFragmentL(iOutgoingSignallingMessage, iBearerMTU));

			if (ret!=KErrNone)

				{

				iMoreFrags = EFalse;

				iOutgoingSignallingMessage.Free();

				// error the user

				iCurrentTransaction->Error(ret);

				return;

				}

			}

		// write outgoing fragments to bearer

		TInt sent = iBearer->Write(iOutgoingSignallingMessage,NULL);

		if (!sent)

			{

			// leave fragment there for next time writing

			SetBlocked(ETrue);

			}

		else

			{

			iOutgoingSignallingMessage.Free();

			if (!iMoreFrags)

				{

				// that message has been completely sent

				PacketSent(*iCurrentTransaction);

				}

			}

		if (!iQueuedMessages.IsEmpty())

			{

			// more to send, send asynchronously.

			StartTryToSendCallback();

			}

		else if (iTryToSendCallback->Priority()==KAvdtpReleaseAcceptPriority)

            {

            // cancel the Release send boost (actually might want to use boosting

            // to clear remaining fragments of partially sent commands)

            iTryToSendCallback->SetPriority(CActive::EPriorityStandard);

            }

   		}

	}

/*static*/ TInt CSignallingChannel::TryToSendCallback()

	{

	LOG_STATIC_FUNC

	ServiceOutboundQueue();

	return EFalse;

	}

TBTDevAddr CSignallingChannel::RemoteAddress()

	{

	LOG_FUNC

	if (iBearer && IsListening())

		{

		TL2CAPSockAddr remote;

		iBearer->RemName(remote);		

		iRemoteAddress = remote.BTAddr();

		}

	if (iBearer)

		{

		return iRemoteAddress;

		}

	else

		{

		return TBTDevAddr(0);

		}

	}

void CSignallingChannel::LogicalChannelFactoryRequestComplete(TLogicalChannelFactoryTicket aTicket, TInt aError)

	{

	LOG_FUNC

	if (aError == KErrNone)

		{

		iLogicalChannelRequest = aTicket;

		TLogicalChannelRecord rec = aTicket.GetLogicalChannel();

		// we take this "out" of the logical channel for performance reasons

		// (the pending logical channel will then die at some point later)

		iBearer = rec.iLogicalChannelSAP;

		iBearer->SetNotify(this);

		// get the MTU now

		ObtainMTU();

		// decide on our address (we may have been passive)

		// to let clients know we signal all the Signal Receivers

		TDblQueIter<XAvdtpSignalReceiver> iter(iPermanentUsers);

		while (iter)

			{

			iter++->SignallingChannelReady(*this);

			}

		// migrate all the current listening sessions, to this new channel

		// if their clients not happy they can detach and relisten for new connection

		// just as if they got an inbound connection - which this is like

		// whether it really is passive l2cap, or was initiated by any one session

		iProtocol.ConnectSignallingListeners(*this);

		// process any already received inbound data

		if (rec.iDataCount)

			{

			NewData(rec.iDataCount);

			}

		if (rec.iEndOfData)

			{

			NewData(KNewDataEndofData);

			Disconnect();

			}

		}

	else

		{

		// to let clients know we signal all the Signal Receivers

		TDblQueIter<XAvdtpSignalReceiver> iter(iPermanentUsers);

		while (iter)

			{

			iter++->SignallingChannelError(aError);

			}

		if (IsIdle())

			{

			IdledD();

			}

		}

	}

TInt CSignallingChannel::AttachSignallingUser(XAvdtpSignalReceiver& aUser)

	{

	LOG_FUNC

	// must check they're not already in the queue

#ifdef _DEBUG

	TDblQueIter<XAvdtpSignalReceiver> iter(iPermanentUsers);

	while (iter)

		{

		if (iter++ == &aUser)

			{

			Panic(EAvdtpBadSignallingUserQueue);

			}

		}

#endif

	TBool isFirstUser = iPermanentUsers.IsEmpty();

	TInt ret = KErrNone;

	iPermanentUsers.AddFirst(aUser);

	if (iBearer)

		{

		aUser.SignallingChannelReady(*this);

		}

	else if(isFirstUser)

		{

		// kick off the need for a signalling channel - we have a user

		// form a request

		if (!IsListening())

			{

			TRAP(ret, iLogicalChannelRequest = iLogicalChannelFactory.CreateSignallingLogicalChannelL(iRemoteAddress, *this));

			}

		else

			{

			TRAP(ret, iLogicalChannelRequest = iLogicalChannelFactory.ExpectSignallingLogicalChannelL(*this));

			}

		}

	return ret;

	}

void CSignallingChannel::DetachSignallingUser(XAvdtpSignalReceiver& aUser)

	{

	LOG_FUNC

	aUser.iSignalReceiverEmbeddedLink.Deque();

	// cleanup any requests they had outstanding

	RemoveTransactions(aUser);

	if (IsIdle())

		{

		if(!IsListening())

			{

			QueIdleTimer();

			}

		else

			{

			//listener just dies

			IdledD();

			}

		}

	}

TBool CSignallingChannel::IsIdle() const

	{

	LOG_FUNC

	// idle if permanent users empty, and transient users haven't got stuff queued

	return (iPermanentUsers.IsEmpty() && iTransactions.IsEmpty());

	}

void CSignallingChannel::QueIdleTimer()

	{

	LOG_FUNC

	CancelIdleTimer();

	iIdleTimerActive = ETrue;	

	BTSocketTimer::Queue(KAvdtpSignallingChannelIdleTimeout, iIdleTimerEntry);

	}

void CSignallingChannel::CancelIdleTimer()

	{

	LOG_FUNC

	if(iIdleTimerActive)

		{

		// there's something to cancel

		iIdleTimerActive = EFalse;

		BTSocketTimer::Remove(iIdleTimerEntry);

		}

	}

/*static*/ TInt CSignallingChannel::TryToClose(TAny* aSignallingChannel)

	{

	LOG_STATIC_FUNC

	// check if still idle

	CSignallingChannel* sigch = reinterpret_cast<CSignallingChannel*>(aSignallingChannel);

	if (sigch->IsIdle())

		{

		sigch->IdledD();

		}

	return EFalse;

	}

void CSignallingChannel::IdledD()

	{

	LOG_FUNC

	// we are till idle

	__ASSERT_ALWAYS(iDraftMessages.IsEmpty(), Panic(EAvdtpSignallingChannelDyingWithDraftMessagesOnQueue));

	__ASSERT_ALWAYS(iTransactions.IsEmpty(), Panic(EAvdtpSignallingChannelDyingWithTransactionsOnQueue));

	__ASSERT_ALWAYS(iQueuedMessages.IsEmpty(), Panic(EAvdtpSignallingChannelDyingWithMessagesOnQueue));

	delete this;

	}

/*

Remove transactions held by a user

*/

void CSignallingChannel::RemoveTransactions(XAvdtpSignalReceiver& aUser)

	{

	LOG_FUNC

	TDblQueIter<CSignallingTransaction> iter(iTransactions);

	while (iter)

		{

		CSignallingTransaction* transaction = iter++;

		if (transaction->User() == &aUser)

			{

			transaction->iLink.Deque();

			delete transaction;

			// outbound queue may now be empty

			CheckOutboundQueue();			

			}

		}

	}

void CSignallingChannel::NewData(TUint aCount)

	{

	LOG_FUNC

	// read out now (could make this async though)

	// just give to inbound message

	TInt res = iInboundMessage.NewData(aCount);

	if (res!=KErrNone)

		{

		// have to error this channel

		Error(res);

		}

	}

/**

Called by packet as it builds itself up - get stuff out of bearer now

The service provided is always to fetch an MTU's worth

*/

TInt CSignallingChannel::GetData(RMBufChain& aData, TUint aOptions, TSockAddr* aAddr)

	{

	LOG_FUNC

	return iBearer->GetData(aData,iBearerMTU,aOptions,aAddr);

	}

/**

Upcall from L2CAP - it is now ready to send

*/	

void CSignallingChannel::CanSend()

	{

	LOG_FUNC

	SetBlocked(EFalse);

	StartTryToSendCallback();

	}

void CSignallingChannel::ConnectComplete()

	{

	LOG_FUNC

	// the factory would have done this by now

	}

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

	{

	LOG_FUNC

	// the factory would have done this by now

	}

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

	{

	LOG_FUNC

	// the factory would have done this by now

	}

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

	{