// Copyright (c) 2005-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 AVCTP protocol object

// 

//

/**

 @file

 @internalTechnology

*/

#include <e32def.h>

#include <bluetooth/logger.h>

#include <bluetoothav.h>

#include "Avctp.h"

#include "avctpsap.h"

#include "avctpmuxerstates.h"

#include "avctpconstants.h" 

#include "IncomingConnListener.h"

#include "avctpPacketMgr.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVCTP);

#endif

#ifdef _DEBUG

PANICCATEGORY("avctp");

#endif

using namespace SymbianAvctp;

#include "avctpmuxer.h"

#ifdef __FLOG_ACTIVE

#define LOG_SAPS LogSaps();

#define LOG_MUXERS LogMuxers();

#define LOG_SAPLINKSMGRS LogSapLinkMgrs();

#else

#define LOG_SAPS

#define LOG_MUXERS

#define LOG_SAPLINKSMGRS

#endif

/** 

Protocol object constructor.

@see CBTSecMan

@param aSecMan The Bluetooth security manager

@param aControlPlane the object which the protocol can use to pass control plane messages

@param aCodMan the CoD manager for the protocol

@return A pointer to the AVCTP protocol object

@internalComponent

*/

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

:	CBluetoothProtocolBase(aSecMan, aControlPlane, aCodMan),

	iSaps(_FOFF(CAvctpSap, iQueLink)),

	iTransports(_FOFF(CAvctpTransport, iQueLink)),

	iIpidResponses(_FOFF(HAvctpOutgoingSdu, iQueLink))

	{

	LOG_FUNC

	TCallBack callBack(TryToClose, this);

	iIdleTimerEntry.Set(callBack);

	}

/** Static protocol object factory function.

Leaves the protocol object on the cleanup stack.

@see CBTSecMan

@param aSecMan The Bluetooth security manager

@param aControlPlane the object which the protocol can use to pass control plane messages

@param aCodMan the CoD manager for the protocol

@return A pointer to the AVCTP protocol object

@leave KErrNoMemory if the protocol object could not be created

@internalComponent

*/

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

	{

	CONNECT_LOGGER

	LOG_STATIC_FUNC

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/** Static protocol object factory function.

@see CBTSecMan

@param aSecMan The Bluetooth security manager

@param aControlPlane the object which the protocol can use to pass control plane messages

@param aCodMan the CoD manager for the protocol

@return A pointer to the AVCTP protocol object

@leave KErrNoMemory if the protocol object could not be created

@internalComponent

*/

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

	{

	LOG_STATIC_FUNC

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

	CleanupStack::Pop(self);

	return self;

	}

/** Protocol object second-phase construction.

@internalComponent

*/

void CAvctpProtocol::ConstructL()

	{

	LOG_FUNC

	iMuxerStateFactory = CAvctpMuxerStateFactory::NewL();

	TCallBack cb(IpidAsyncCallBack, this);

	iIpidResponseAsyncCallBack = new (ELeave)CAsyncCallBack(cb, EActiveHighPriority);

	}

/** Protocol object destructor.

We don't clear up the SAPs, or the Muxer Collections as they are owned by ESock

and it is up to it to destroy them.

 muxers are owned by the protocol and so should be destroyed by it.

@internalComponent

*/

CAvctpProtocol::~CAvctpProtocol()

	{

	LOG_FUNC

	DequeIdleTimer();

	if (LowerProtocol())

		{

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

		}

	CancelIpidAsyncCallBack();

	delete iIpidResponseAsyncCallBack;

	TDblQueIter<HAvctpOutgoingSdu> sduIter(iIpidResponses);

	while(sduIter)

		{

		delete sduIter++; // deques sdu

		}				

	TDblQueIter<CAvctpTransport> muxerIter(iTransports);

	while(muxerIter)

		{

		delete muxerIter++; // deques muxer

		}	

	delete iMuxerStateFactory;

	// iListener is deleted through CBluetoothProtocolBase

	delete iSecondChannelListener;

	iClientItems.Close();

	}

/** Pre-binding initialise.

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

@internalAll

@leave KErrNoMemory if the state factory cannot be created

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

*/

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

	{

	LOG_FUNC

	}

/** Binding complete.

@internalAll

*/

void CAvctpProtocol::StartL()

	{

	LOG_FUNC

	// Should check that we're bound now.

	if (!iLowerProtocol)

		{

		User::Leave(ENotBound);

		}

	User::LeaveIfError(IncrementListeners());

	}

/** 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.

@internalAll

@leave KErrProtocolAlreadyBound 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 CAvctpProtocol::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(KErrProtocolAlreadyBound);

		}

	}

/** Create a new SAP.

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.

@internalAll

@leave KErrNotSupported if aSockType is not KSockDatagram, KErrNoMemory if a

     new SAP could not be created

@param aSockType The socket type for the SAP: AVCTP only supports KSockDatagram

@return A pointer to a new SAP

*/

CServProviderBase* CAvctpProtocol::NewSAPL(TUint aSockType)

	{

	LOG_FUNC

	CBluetoothSAP* sap = NULL;

	switch(aSockType)

		{

	case KSockDatagram:    // AVCTP uses datagrams for data SAPs

		sap = CAvctpSap::NewL(*this);

		break;

	case KSockRaw:    // AVCTP uses Raw for control SAPs

		sap = CAvctpControlSAP::NewL(*this);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return sap;

	}

/** Identify the protocol.

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

@internalAll

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

*/

void CAvctpProtocol::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.

@internalComponent

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

*/

void CAvctpProtocol::ProtocolIdentity(TServerProtocolDesc* aDesc)

	{

	LOG_STATIC_FUNC

	_LIT(KAvctpProtocolName,"AVCTP"); 

	aDesc->iName			= KAvctpProtocolName;

	aDesc->iAddrFamily		= KBTAddrFamily;

	aDesc->iSockType		= KUndefinedSockType; // can support datagram AND raw

	aDesc->iProtocol		= KAVCTP;

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

	aDesc->iByteOrder		= ELittleEndian;

	aDesc->iServiceInfo		= KServiceInfo;

	aDesc->iNamingServices	= NULL;

	aDesc->iSecurity		= KSocketNoSecurity; // cause we do our own

	aDesc->iMessageSize		= KSocketMessageSizeNoLimit; // we can fragment to our heart's content

	aDesc->iServiceTypeInfo	= KServiceTypeInfo;

	aDesc->iNumSockets		= KMaxNumSocketsInProtocol;

	}

/** Our protocol reference in esock 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 pre-empted by another open.

@internalAll

*/

void CAvctpProtocol::CloseNow()

	{

	LOG_FUNC

	iClosePending = ETrue;

	// We can only assert there are no saps cause the sap links mgrs are asynchronously deleted

	// and so may still be around at this point. However they should've been deleted by the

	// time TryToClose is called so we assert IsIdle() there.

	ASSERT_DEBUG(iSaps.IsEmpty());

	QueIdleTimer();

	}

/** 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.

@internalAll

*/

void CAvctpProtocol::Open()

	{

	LOG_FUNC

	iClosePending = EFalse;

	DequeIdleTimer();

	CProtocolBase::Open();

	}

/**

   This is one session closing.

*/

void CAvctpProtocol::Close()

	{

	LOG_FUNC

	CProtocolBase::Close();

	}

/**

Helper to actually start listening. This protocol doesn't use the base class

implementation as it needs to do a bit more.

@internalComponent

*/

void CAvctpProtocol::DoStartAvctpListeningL()

	{	

	LOG_FUNC

	const TUint KDefaultMtu = 335;

	CServProviderBase* sap =iLowerProtocol->NewSAPL(KSockSeqPacket);

	CleanupStack::PushL(sap);

	TBTSockAddr localAddr;

	localAddr.SetPort(KAVCTP);

	// the security settings are:	

	// (though see :Preauthorise() for the authentication exceptions due to avdtp authentication)

	TBTServiceSecurity sec;

	sec.SetAuthentication(KInboundAuthenticationDefault);

	sec.SetAuthorisation(KInboundAuthoristationDefault);

	sec.SetEncryption(KInboundEncryptionDefault);

	sec.SetDenied(EFalse);

	sec.SetUid(KAvctpServiceUid);

	localAddr.SetSecurity(sec);

	CleanupStack::Pop(sap);

	iListener = CIncomingConnectionListener::NewL(*this, sap, localAddr, KProtocolListeningQueueSize);										

	CServProviderBase* sap2 =iLowerProtocol->NewSAPL(KSockSeqPacket);

	CleanupStack::PushL(sap2);

	TPckgBuf<TL2CapConfig> config;

	config().SetMaxTransmitUnitSize(KAvctpSecondaryChannelInboundMTU);

	config().SetMinMTU(KDefaultMtu);

	config().SetMaxReceiveUnitSize(KAvctpSecondaryChannelInboundMTU);

	config().SetMinMRU(KDefaultMtu);

	__DEBUG_ONLY(TInt err =) sap2->SetOption(KSolBtL2CAP, KL2CAPUpdateChannelConfig, config); 

	__ASSERT_DEBUG(err == KErrNone, Panic(ESetOptionError));

	// security for the secondary channel is not required

	sec.SetAuthentication(KSecondaryChannelAuthenticationDefault);

	sec.SetAuthorisation(KSecondaryChannelAuthoristationDefault);

	sec.SetEncryption(KInboundEncryptionDefault);

	sec.SetDenied(EFalse);

	sec.SetUid(KAvctpServiceUid);	

	localAddr.SetSecurity(sec);

	localAddr.SetPort(KAvctpSecondChannelPSM);

	CleanupStack::Pop(sap2);

	iSecondChannelListener  = CIncomingConnectionListener::NewL(*this, sap2, localAddr, KProtocolListeningQueueSize);										

	}

/**

AVCTP connection listener connect complete function (cloned SAP overload).

Part of the MSocketNotify interface.

Called by the listening L2CAP SAP when an incoming connection occurs.

This checks with the protocol to check for an existing muxer - if there

is one, an error is returned and the new L2CAP SAP is shut down (the 

remote device should be using the existing muxer). If not, the SAP is

given to the muxer.

@internalAll

@param aSap The SAP for the new lower layer connection

*/

TInt CAvctpProtocol::BearerConnectComplete(const TBTDevAddr& aAddr, CServProviderBase* aSSP)

	{

	LOG_FUNC

	IF_FLOGGING

		(

		TBuf<KBTAddressLength> address; 

		aAddr.GetReadable(address);

		)

	LOG1(_L("from BT Device 0x%S"), &address);

	// NB: If no error occurs, ownership of aSSP passes to the muxer.

	// If an error does occur then the CIncomingConnectionListener will take care of aSSP for us

	TInt err = AttachInboundConnectionToTransport(aAddr, aSSP);

	return err;

	}

/**

Control plane message delivery system between protocols

@return error as a result of processing or not consuming the control message

@param aMessage the message

@param aParam arbitrary data for message - knowledge of aMessage allows casting

@see CBTProtocolFamily

@internalComponent

*/

TInt CAvctpProtocol::ControlPlaneMessage(TBTControlPlaneMessage aMessage, TAny* aParam)

	{

	LOG_FUNC

	// only ones applicable to this protocol at present are 

	// for preauthorising a device - must have come from AVCTP, with PID=RCP

	TInt ret = KErrNotSupported;

	switch (aMessage)

		{

		case EPreauthoriseDevice:

			{

			__ASSERT_DEBUG(aParam, Panic(EProtocolReceivingBadlyFormedControlMessage));

			const TOverrideAuthorise& override = *reinterpret_cast<const TOverrideAuthorise*>(aParam);

			__ASSERT_DEBUG(override.iAuthorisingProtocol == KAVDTP, Panic(EProtocolReceivingControlFromUnexpectedProtocol));

			SetPreauthorisation(override.iPreauthorisedRemoteAddress,

								override.iPreauthorise);

			ret = KErrNone;							

			break;

			}

		default:

			__ASSERT_DEBUG(aParam, Panic(EProtocolReceivingBadlyFormedControlMessage));

		}

	return ret;

	}

/**

Helper to hide the need to supply the socket level to which preauthorisation pertains

@param aPreauthoriseAddress the address of the device to preauthorise

@param aSetPreauthorisation ETrue if the device is allowed to be authorised for other AVDTP/AVCTP connection, EFalse to cancel

@internalComponent

*/

TInt CAvctpProtocol::SetPreauthorisation(const TBTDevAddr& aPreauthoriseAddress, TBool aSetPreauthorisation)

	{

	LOG_FUNC

	TInt ret = KErrNone;

	if (IsListening())

		{

		if (aSetPreauthorisation && !Listener().IsPreauthorised(KSolBtL2CAP, aPreauthoriseAddress))

			{

			Listener().SetPreauthorisation(KSolBtL2CAP, aPreauthoriseAddress, ETrue);

			// tell AVDTP

			TOverrideAuthorise override;

			override.iAuthorisingProtocol = KAVCTP;

			override.iAuthorisingPort = KAvrcpPid;			

			override.iPreauthorise = aSetPreauthorisation;

			override.iPreauthorisedRemoteAddress = aPreauthoriseAddress;

			ControlPlane().Preauthorise(KAVDTP, override);

			}

		else if (!aSetPreauthorisation)

			{

			Listener().SetPreauthorisation(KSolBtL2CAP, aPreauthoriseAddress, EFalse);			

			}

		// else do nothing

		}

	else

		{

		ret = KErrNotReady;

		}

	return ret;