// 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 protocol object

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include <e32def.h>

#include <bluetoothav.h>

#include <bluetooth/avctptypes.h> // for PID used for pre-authorisation

#include "IncomingConnListener.h"

#include "avdtp.h"

#include "avdtpsap.h"

#include "avdtpTransportChannel.h"

#include "avdtpTransportSession.h"

#include "avdtpSignallingChannel.h"

#include "avdtpStream.h"

#include "avdtputil.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);

#endif

/**

Protocol object constructor.

@internalComponent

@param aSecMan The bluetooth security manager

@see CBTSecMan

@return A pointer to the AVDTP protocol object

*/

CAvdtpProtocol::CAvdtpProtocol(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

:	CBluetoothProtocolBase(aSecMan, aControlPlane, aCodMan),

	iTransportChannels(_FOFF(CTransportChannel, iProtocolQLink)),

	iClosingTransportChannels(_FOFF(CTransportChannel, iProtocolQLink)),

	iSignallingChannels(_FOFF(CSignallingChannel, iProtocolQLink)),

	iStreams(_FOFF(CAVStream, iProtocolQLink)),

	iSecondarySAPs(_FOFF(CAvdtpSAP, iLink))

	{

	CONNECT_LOGGER

	LOG_FUNC

	TCallBack cb(TryToClose, this);

	iIdleTimerEntry.Set(cb);

	}

/**

Protocol object destructor.

We don't clear up the SAPs as they are owned by ESock and it is up to it to destroy them.

@internalComponent

*/

CAvdtpProtocol::~CAvdtpProtocol()

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iIdleEntryQueued, Panic(EAvdtpProtocolDeletionWhilstIdling));

	RemoveIdleTimerEntry();

	if (iLowerProtocol)

		iLowerProtocol->Close();  // Matches the bind

	delete iLogicalChannelFactory;

	delete iStreamStateFactory;

	delete iRemoteSEPCache;

	__ASSERT_ALWAYS(iStreams.IsEmpty(), Panic(EAvdtpProtocolDyingWithStreamsOnQueue));

	__ASSERT_ALWAYS(iSignallingChannels.IsEmpty(), Panic(EAvdtpProtocolDyingWithSignallingChannelsOnQueue));

	__ASSERT_ALWAYS(iTransportChannels.IsEmpty(), Panic(EAvdtpProtocolDyingWithTransportChannelsOnQueue));

	__ASSERT_ALWAYS(iClosingTransportChannels.IsEmpty(), Panic(EAvdtpProtocolDyingWithTransportChannelsOnQueue));

	CLOSE_LOGGER

}

/**

Static protocol object factory function.

Leaves the protocol object on the cleanup stack.

@internalComponent

@see CBTSecMan

@leave KErrNoMemory if the protocol object could not be created

@param aSecMan The bluetooth security manager

@return A pointer to the AVDTP protocol object

*/

CAvdtpProtocol* CAvdtpProtocol::NewLC(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

	{

	LOG_STATIC_FUNC	

	CAvdtpProtocol* self = new(ELeave) CAvdtpProtocol(aSecMan, aControlPlane, aCodMan);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

Static protocol object factory function.

@internalComponent

@see CBTSecMan

@leave KErrNoMemory if the protocol object could not be created

@param aSecMan The bluetooth security manager

@return A pointer to the AVDTP protocol object

*/

CAvdtpProtocol* CAvdtpProtocol::NewL(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

	{

	LOG_STATIC_FUNC

	CAvdtpProtocol* self = CAvdtpProtocol::NewLC(aSecMan, aControlPlane, aCodMan);

	CleanupStack::Pop(self);

	return self;

	}

/**

Protocol object second-phase construction

@internalComponent

*/

void CAvdtpProtocol::ConstructL()

	{

	LOG_FUNC

	iStreamStateFactory = CAVStreamStateFactory::NewL();

	iRemoteSEPCache = CRemoteSEPCache::NewL();

	}

/**

Pre-binding initialise.

Alloc any stuff we need. This will only ever be called once during the lifetime of this protocol.

@internalComponent

@leave KErrNoMemory if the state factory cannot be created

@param aTag The string identifier for the protocol from the ESock ini file

*/

void CAvdtpProtocol::InitL(TDesC& /*aTag*/)

	{

	LOG_FUNC

	}

/**

Binding complete.

@internalComponent

*/

void CAvdtpProtocol::StartL()

	{

	LOG_FUNC

	// Should check that we're bound now.

	if (!iLowerProtocol)

		{

		User::Leave(KErrAvdtpNotBound);

		}

	iLogicalChannelFactory = CLogicalChannelFactory::NewL(*this, *iLowerProtocol);

	}

// From higher protocol

void CAvdtpProtocol::BindL(CProtocolBase* /*protocol*/, TUint /* id*/)

	{

	LOG_FUNC

	// Could register the protocol that's bound to us

	// (e.g. "see" whether we support RTCP/RTP-FEC (if that

	// protocol suite becomes ESOCK-side!)

	}

/**

Request by Protocol Mgr to bind to the specified protocol. We can only be bound

to one lower layer protocol, so the function leaves if we are already bound.

@internalComponent

@leave KErrAvdtpAlreadyBound if we are already bound, and any other leave from

     the lower protocol's BindL()

@param aProtocol The protocol we need to bind to.

*/

void CAvdtpProtocol::BindToL(CProtocolBase* aProtocol)

	{

	LOG_FUNC

	if(!iLowerProtocol)

		{

#ifdef _DEBUG

		TServerProtocolDesc prtDesc;

		aProtocol->Identify(&prtDesc);

		if(prtDesc.iAddrFamily!=KBTAddrFamily ||

		   prtDesc.iProtocol!=KL2CAP)

			{

			User::Leave(KErrBtEskError);

			}

#endif

		iLowerProtocol=static_cast<CBluetoothProtocolBase*>(aProtocol);

		iLowerProtocol->BindL(this, 0); // id not used

		iLowerProtocol->Open();

		}

	else

		{

	    User::Leave(KErrAvdtpAlreadyBound);

		}

	}

void CAvdtpProtocol::Close()

	{

	LOG_FUNC

	CProtocolBase::Close();

	}

/** 

Create a new SAP: all SAPs are datagram.

The SAP will eventually construct a session, to which the SAP delegates

most of its work.  This is reminiscent of the Adaptor pattern.

The delegate represents a session as per the AVDTP specification.

Note that this implmentation adds to the available session types with

the signalling session.  This allows for multiplexed use of the signalling

channel.

The SAP returned is owned by the caller -- this protocol will not clean it up.

ESock uses this function to create a new SAP, and ESock will delete when it is

finished with it.

In future this could take care of secondary saps - make them !datagram

@internalComponent

@leave KErrNotSupported if aSockType is not datagram

@param aSockType The socket type for the SAP:

@return A pointer to a new SAP

*/

CServProviderBase* CAvdtpProtocol::NewSAPL(TUint aSockType)

	{

	LOG_FUNC

	CAvdtpSAP* sap = NULL;

	switch(aSockType)

		{		

		case KSockDatagram:

			sap = CAvdtpSAP::NewL(*this);

			break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	return sap;

	}

/**

Identify the protocol.

The descriptor is filled in to identify the protocol to ESock.

@internalComponent

@param aDesc A pointer to the descriptor to be filled in

*/

void CAvdtpProtocol::Identify(TServerProtocolDesc* aDesc) const

	{

	LOG_FUNC

	ProtocolIdentity(aDesc);

	}

/**

Fill in the protocol descriptor.

This is a static utility function to fill in the protocol details.

Called from family too.

@internalComponent

@param aDesc A pointer to the descriptor to be filled in

*/

void CAvdtpProtocol::ProtocolIdentity(TServerProtocolDesc* aDesc)

	{

	LOG_STATIC_FUNC

	aDesc->iName			= KAVDTPProtocolName;

	aDesc->iAddrFamily		= KBTAddrFamily;

	aDesc->iSockType		= KSockDatagram; // because of bearing rtp

	aDesc->iProtocol		= KAVDTP;

	aDesc->iVersion			= TVersion(KBTMajor,KBTMinor,KBTBuild);

	aDesc->iByteOrder		= ELittleEndian;

	aDesc->iServiceInfo		= KAvdtpServiceInfo;

	aDesc->iNamingServices	= NULL;

	aDesc->iSecurity		= KSocketNoSecurity;

	aDesc->iMessageSize		= KSocketMessageSizeUndefined; // whatever l2cap dynamically. not static knowledge of max

	aDesc->iServiceTypeInfo	= ESocketSupport | ECantProcessMBufChains |

							  EPreferDescriptors | EUseCanSend;

	aDesc->iNumSockets		= 100;

	}

/**

Our reference is now zero, so start to close.

We don't actually close, merely Q a timer for a later close down.

This close can be prempted by another open.

@internalComponent

*/

void CAvdtpProtocol::CloseNow()

	{

	LOG_FUNC

	iClosePending = ETrue;

	QueIdleTimerEntry();

	}

void CAvdtpProtocol::Open()

/**

Request to open the protocol.

The protocol may be repeatedly opened and closed.  The order of calls is

InitL, [Open *n , Close * n,  CloseNow] * m etc.

@internalComponent

*/

	{

	LOG_FUNC

	iClosePending = EFalse;

	RemoveIdleTimerEntry();

	CProtocolBase::Open();

	}

/**

Create a signalling channel for listening - this has the special address of 0

*/

CSignallingChannel* CAvdtpProtocol::CreateSignallingChannelForListening()

	{

// the signalling channel with addr=0 *is* the listener

	LOG_FUNC

	return GetSignallingChannel(TBTDevAddr(0));

	}

/**

For an open platform we need to support shared use of the Signalling Channel

Signalling sessions ask for this then and attach themselves to it

*/

CSignallingChannel* CAvdtpProtocol::FindSignallingChannel(const TBTDevAddr& aRemoteAddr)

	{

	LOG_FUNC

	CSignallingChannel* c = NULL;

	TDblQueIter<CSignallingChannel> iter(iSignallingChannels);

	while (iter)

		{

		c = iter++;

		if (c->iRemoteAddress==aRemoteAddr)

			{			

			return c;

			}

		}

	return NULL;	

	}

CSignallingChannel* CAvdtpProtocol::FindListeningSignallingChannel()

	{

	LOG_FUNC

	CSignallingChannel* c = NULL;

	TDblQueIter<CSignallingChannel> iter(iSignallingChannels);

	while (iter)

		{

		c = iter++;

		if (c->IsListening())

			{			

			return c;

			}

		}

	return NULL;	

	}

CSignallingChannel* CAvdtpProtocol::GetSignallingChannel(const TBTDevAddr& aRemoteAddr) 

	{

	LOG_FUNC

	// if not found, create one else return it

	CSignallingChannel* ch = FindSignallingChannel(aRemoteAddr);

	if (!ch)

		{

		TRAP_IGNORE(ch = CSignallingChannel::NewL(*this, *iLogicalChannelFactory, aRemoteAddr));

		if (ch)

			{

			iSignallingChannels.AddFirst(*ch);

			}

		}

	return ch;

	}

/**

This function transfers sessions attached to a listening channel to the connected signalling

channel. It is only effective if the connected channel is the result of an active open rather

than an incoming connection. This function does nothing in the latter case.

*/

void CAvdtpProtocol::ConnectSignallingListeners(CSignallingChannel& aConnectedSignallingChannel)

	{

	LOG_FUNC

	CSignallingChannel* listeningChannel = FindListeningSignallingChannel();

	if (listeningChannel)

		{

		// take off all the sessions, and re-attach to the connected signalling channel

		TDblQueIter<XAvdtpSignalReceiver> listeningIter(const_cast<TDblQue<XAvdtpSignalReceiver>&>

											(listeningChannel->Users()));

		XAvdtpSignalReceiver* user;

		while ((user = listeningIter++) != NULL)

			{

			listeningChannel->DetachSignallingUser(*user);

			aConnectedSignallingChannel.AttachSignallingUser(*user);

			}	

		}

	// else do nothing

	}

/**

Find a transport channel for a transport session to bind to, allocate if needed

Ownership is NOT returned - channels own themselves

The protocol keeps a reference to the channel in a queue

so that it can hand out further references (in the form of pointers) as needed

Algorithm is thus:

1) Deduce session type this channel would be for: s

2) Deduce device address this channel would be for: d

3) Deduce Stream this channel would be for: S

4) Find the stream container object for S - this say if we can mux

5) If mux then find a TC with different S if s = Recovery

6) elseif !mux then create new TC

*/

CTransportChannel* CAvdtpProtocol::GetTransportChannel(const TAvdtpSockAddr& aRemoteAddr,

													 	TBool aUseMux,

													 	TTCID aRemotelyAssignedTTCID/*=KInvalidTCID*/)

	{

	LOG_FUNC

	CTransportChannel* tc = NULL;

	if (aUseMux)

		{

		// try to find a TC we already have on which this session can go

		TDblQueIter<CTransportChannel> iter(iTransportChannels);

		while (iter)

			{

			CTransportChannel* possibleChannel = iter++;

			if (possibleChannel->CouldAttachSession(aRemoteAddr))

				{

				// found one

				tc = possibleChannel;

				break;

				}

			}

		}

	if (!tc)

		{

		// we now know we do actually need a new TC

		// ***but don't connect it yet***

		__ASSERT_DEBUG(FindSignallingChannel(aRemoteAddr.BTAddr()), Panic(EAvdtpSignallingChannelShouldExist));

		// spec is unclear but it is the case that only mux channels get assigned TCIDs

		TInt err = KErrNone;

		if (aUseMux)

			{

			TRAP(err, tc = CTransportChannel::NewMuxChannelL(*this, 

											aRemoteAddr.BTAddr(),

								 			aRemotelyAssignedTTCID));

			}

		else

			{

			TRAP(err, tc = CTransportChannel::NewDirectChannelL(*this, 

											aRemoteAddr.BTAddr()));

			}

		if (err==KErrNone)

			{

			iTransportChannels.AddFirst(*tc);

			}

		}

	return tc;

	}

/**

Find transport channel with TCID==aTCID

If not found return NULL - do not create (like the Get method)

There is no need to search for Direct Channels so this is asserted against

*/

CTransportChannel* CAvdtpProtocol::FindMuxChannel(TTCID aTCID)

	{

	LOG_FUNC

	__ASSERT_DEBUG(aTCID!=KDirectChannelTCID, Panic(EAvdtpSearchingForDirectChannel));

	TDblQueIter<CTransportChannel> iter(iTransportChannels);

	CTransportChannel* tc = NULL;

	while (iter)

		{

		tc = iter++;

		if (tc->TCID() == aTCID)

			{

			// found it

			__ASSERT_DEBUG(tc->TCID()!=KDirectChannelTCID, Panic(EAvdtpIncorrectlyFoundDirectChannel));

			break;

			}

		}

	return tc;

	}

/**

Called by the transport channel when it's dead

eg when link lost, or graceful close completed

@internalComponent

@param aTransportChannel The channel that's down

*/

void CAvdtpProtocol::TransportChannelDown(CTransportChannel& aTransportChannel)