// 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 code for AVCTP SAPs

// 

//

/**

 @file

 @internalTechnology

*/

#include <bluetooth/logger.h>

#include <es_mbuf.h>

#include "Avctp.h"

#include "avctpsap.h"

#include "avctpmuxer.h"

#include "avctpcommon.h"

#include "avctputils.h"

#include "avctppacket.h"

#include "avctpPacketMgr.h"

#include "AvctpMessageParameters.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVCTP);

#endif

#ifdef _DEBUG

PANICCATEGORY("avctpsap");

#endif

using namespace SymbianAvctp;

/** 

Avctp Sap Security policy  

We don't need to check LocalServices as BluetoothSAP does that for us

*/

_LIT_SECURITY_POLICY_S0(KAvctpSapSecurityPolicy, KDefaultSidforPids);

/** Diagnostic string identifying this module when calling security policy checking methods,

in builds without platsec diagnostics this will be NULL */

const char * const KAvctpSapSecurityPolicyDiagnostic = __PLATSEC_DIAGNOSTIC_STRING("Avctp Sap");

/**

Static AVCTP SAP factory function

  @internalComponent

  @leave KErrNoMemory if the SAP object could not be allocated

  @param aProt Lower protocol object

  @return A pointer to the new SAP

*/

CAvctpSap* CAvctpSap::NewL(CAvctpProtocol& aProt)

	{

	LOG_STATIC_FUNC

	CAvctpSap* sap = new(ELeave) CAvctpSap(aProt);

	CleanupStack::PushL(sap);

	sap->ConstructL();

	CleanupStack::Pop(sap);

	return sap;

	}

/**

Second-phase construction of a SAP

Set up the async. callback.

  @internalComponent

*/

void CAvctpSap::ConstructL()

	{

	LOG_FUNC

	CBluetoothSAP::ConstructL();

	TCallBack cb(SendAsyncCallBack, this);

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

	}

/**

Constructor for an AVCTP SAP

  @internalComponent

  @param aProt The AVCTP protocol object

*/

CAvctpSap::CAvctpSap(CAvctpProtocol& aProtocol)

	: CBluetoothSAP(aProtocol.SecMan(), aProtocol.CodMan()),

	  iProtocol(aProtocol),

	  iOutgoingSdus(),

	  iIncomingSdus(_FOFF(HAvctpIncomingSdu, iQueLink)),

	  iChannel(KAvctpInvalidChannel),

	  iIsInList(EFalse)

	{

	LOG_FUNC

	// we set the channel because "0" is a real channel, so we want to know that iChannel is unset at time of construction

	}

/**

Destructor for an AVCTP SAP

Called when ESock deletes the SAP, when user app calls RSocket::Close()

  @internalAll

*/

CAvctpSap::~CAvctpSap()

	{

	LOG_FUNC

	// Delete any remaining packets that the sap owns

	TDblQueIter<HAvctpOutgoingSdu> outgoingIter = iOutgoingSdus.Iter();

	while (outgoingIter)

		{

		delete outgoingIter++; // deques sdu

		}

	TDblQueIter<HAvctpIncomingSdu> incomingIter(iIncomingSdus);

	while (incomingIter)

		{

		delete incomingIter++; // deques sdu

		}	

	iSendAsyncCallBack->Cancel();

	delete iSendAsyncCallBack;

	}

MSocketNotify& CAvctpSap::Socket() const

	{

	LOG_FUNC

	__ASSERT_DEBUG(iSocket, Panic(EAvctpDataSAPNullSocket));

	return *iSocket;

	}

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

/* Implementation of CControlledServProvider methods */

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

/**

Set the local name to anAddr.

@internalAll

@param anAddr The address with the PID

@return KErrNone if successful

*/

TInt CAvctpSap::SetLocalName(TSockAddr& aAddr)

	{

	LOG_FUNC

	TAvctpSockAddr avctpAddr = TAvctpSockAddr::Cast(aAddr);

	iChannel = avctpAddr.Channel(); 

	__ASSERT_DEBUG(iChannel == KAvctpPrimaryChannel || iChannel == KAvctpSecondaryChannel, Panic(EAvctpInvalidChannel));

	TInt err = KErrNone;

	if (iChannel != KAvctpPrimaryChannel && iChannel != KAvctpSecondaryChannel)

		{

		err = KErrInvalidChannel;

		}

	if (err == KErrNone)

		{

		err = SetPid(avctpAddr.Pid());

		}

	if (err == KErrNone)

		{

		err = iProtocol.AddSap(*this);

		}

	return err;

	}

/**

Read the Local Name into anAddr.

AVCTP knows only the PID on which the device is

registered but this is OK since that's all they want.

  @internalAll

  @param anAddr The address to read into

*/

void CAvctpSap::LocalName(TSockAddr& aAddr) const

	{

	LOG_FUNC

	// Copy iPid into TSockAddr and return

	TAvctpSockAddr avctpAddr(aAddr);

	avctpAddr.SetChannel(iChannel);

	avctpAddr.SetPid(iPid);

	aAddr = avctpAddr;

	}

/**

Read the remote name into anAddr.

AVCTP knows only the PID on which the device is

registered but this is OK since that's all they want.

  @internalAll

  @param anAddr The address to read into

*/

void CAvctpSap::RemName(TSockAddr& aAddr) const

	{

	LOG_FUNC

	// no BT Addr to fill on for data saps :-)

	TAvctpSockAddr avctpAddr(aAddr);

	avctpAddr.SetPid(iPid);

	aAddr = avctpAddr;   // Convert back

	}

/**

Set the remote name to anAddr.

  @internalAll

  @param anAddr The address to set

*/

TInt CAvctpSap::SetRemName(TSockAddr& aAddr)

	{

	LOG_FUNC

	// Copy this over

	TAvctpSockAddr avctpAddr = TAvctpSockAddr::Cast(aAddr);

	iChannel = avctpAddr.Channel();

	__ASSERT_DEBUG(iChannel == KAvctpPrimaryChannel || iChannel == KAvctpSecondaryChannel, Panic(EAvctpInvalidChannel));

	TInt err = KErrNone;

	if (iChannel != KAvctpPrimaryChannel && iChannel != KAvctpSecondaryChannel)

		{

		err = KErrInvalidChannel;

		}

	if (err == KErrNone)

		{

		err = SetPid(avctpAddr.Pid());

		}

	return err;

	}

/**

Auto bind from ESock.

We're not expecting this as a connectionless protocol so panic

  @internalAll

*/

void CAvctpSap::AutoBind()

	{

	LOG_FUNC

	__PANIC_UNEXPECTED_CALL

	}

/**

Get a socket option.

AVCTP doesn't support socket options, so fail it if it's for AVCTP.

  @internalAll

  @param aLevel The socket option level

  @param aName The socket option name

  @param aOption The socket option data

*/

TInt CAvctpSap::GetOption(TUint /*aLevel*/, TUint /*aName*/, TDes8& /*aOption*/) const

	{

	LOG_FUNC

	return KErrNotSupported;

	}

/**

Set a socket option. (BluetoothSAP version)

AVCTP doesn't support socket options, so fail it if it's for AVCTP.

  @internalAll

  @param aLevel The socket option level

  @param aName The socket option name

  @param aOption The socket option data

*/

TInt CAvctpSap::SAPSetOption(TUint /*aLevel*/, TUint /*aName*/, const TDesC8& /*aOption*/)

	{

	LOG_FUNC

	return KErrNotSupported;

	}

// start-up/Shutdown

// NB: All ActiveOpen / PassiveOpen / Start calls require a connection-

//     oriented socket, so we just panic!

/**

Active open an AVCTP socket...

Wait a minute!  AVCTP is connectionless, so panic!

  @internalAll

*/

void CAvctpSap::ActiveOpen()

	{

	LOG_FUNC

	Panic(EActiveOpenNotSupported); // control sap does this

	}

/**

Active open an AVCTP socket (data overload)...

Wait a minute!  AVCTP is connectionless, so panic!

  @internalAll

  @param aConnectionData Data to send on connection

*/

void CAvctpSap::ActiveOpen(const TDesC8& /*aConnectionData*/)

	{

	LOG_FUNC

	Panic(EActiveOpenNotSupported);

	}

/**

Passive open an AVCTP socket...

Wait a minute, passive opens are only for connection-oriented protocols too! Panic.

  @internalAll

  @param aQueSize How many connections to complete before they are Accept()ed...

  @return KErrNotSupported, obviously...

*/

TInt CAvctpSap::PassiveOpen(TUint /*aQueSize*/)

	{

	LOG_FUNC

	Panic(EPassiveOpenNotSupported);

	return KErrNotSupported;

	}

/**

Passive open an AVCTP socket (data overload)...

Wait a minute, passive opens are only for connection-oriented protocols too! Panic.

  @internalAll

  @param aQueSize How many connections to complete before they are Accept()ed...

  @param aConnectionData Data to send on connection

  @return KErrNotSupported, obviously...

*/

TInt CAvctpSap::PassiveOpen(TUint /*aQueSize*/, const TDesC8& /*aConnectionData*/)

	{

	LOG_FUNC

	Panic(EPassiveOpenNotSupported);

	return KErrNotSupported;

	}

/**

We ignore this.

  @internalAll

*/

void CAvctpSap::Start()

	{

	LOG_FUNC

	}

/**

Close the SAP down.

  @internalAll

  @param aCloseType How fast we're going down

*/

void CAvctpSap::Shutdown(TCloseType aCloseType)

	{

	LOG_FUNC

	LOG1(_L("option = %d"), aCloseType);

	if (aCloseType != EImmediate)

		{

		// We need to remember we've been asked to close so:

		iIsClosing = ETrue;

		// Normal Shutdown - ESOCK will wait for us to say we can end		

		// Esock is no longer interested in our incoming packets so delete them

		TDblQueIter<HAvctpIncomingSdu> incomingIter(iIncomingSdus);

		while (incomingIter)

			{

			delete incomingIter++; // deques sdu

			}	

		CheckForCanClose();	

		}

	else

		{

		// Note: Esock doesn't require us to call CanClose on an EImmediate Shutdown

		iClosed = ETrue;

		iProtocol.RemoveSap(*this);

		}

	}

/**

Close the SAP down (data overload).

  @internalAll

  @param aCloseType How fast we're going down

  @param aDisconnectionData Data to send on disconnect

*/

void CAvctpSap::Shutdown(TCloseType /*aCloseType*/, const TDesC8& /*aDisconnectionData*/)

	{

	LOG_FUNC

	Panic(EDisconnectDataNotSupported);

	}

/**

Send some data.

Just pass this over to our state.

  @internalAll

  @param aDesc The data to send

  @param aOptions The message parameters

  @param aAddr The address to send to

  @return 0 if the write failed or 1 if we took ownership of the data

*/

TInt CAvctpSap::Write(RMBufChain& aData, TUint aOptions, TSockAddr* aAddr)

	{

	LOG_FUNC

	// We've been asked to close so esock shouldn't be giving us any more data

	__ASSERT_ALWAYS(!iIsClosing, Panic(EUnexpectedEsockEvent));

	TUint ret = 0;

	if (iOutgoingSdus.Count() < KSapOutboundQHighMark)

		{

		TAvctpMessageParameters parameters(aOptions);

		TAvctpNormalHeaderInfo headerInfo = TAvctpNormalHeaderInfo(

												parameters.iTransaction, 

												ENormalPkt, 

												parameters.Type(),

												ETrue, // hasValidPid

												Pid());

		HAvctpOutgoingSdu* sdu = NULL;

		TRAPD(err,sdu = HAvctpOutgoingSdu::NewL(headerInfo, 

												TAvctpSockAddr(*aAddr).BTAddr(),

												aData));

		if (err == KErrNone)

			{

			iOutgoingSdus.Insert(*sdu);

			StartSendAsyncCallBack();

			ret = 1; //one sdu

			}

		}

	if (!ret)

		{

		iSendBlocked = ETrue;

		iPendingSendAddress = TAvctpSockAddr::Cast(*aAddr).BTAddr();

		}

	return ret;

	}

/**

This function is called on the Sap by Esock when it wants to receive the

data we told it about in NewData upcalls from us.

Rather than letting Esock call the descriptor overload, this function

deals with the request directly for two reasons. The intention is to 

implement AVCTP in terms of MBufs in future but also because the descriptor 

overload doesn't get called correctly by esock since it doesn't know how

long our datagrams will be and so presents us with a TDes8 which is too 

short.

  @internalAll

  @param aData The data to be received

  @param aOptions The message parameters

  @param aAddr The address the data is received from

  @return the error associated with the read. Could be KErrNoMBufs (a likely case) in which case esock 

  		   would attempt an allocation for us and would then try again. If it's some other error then it's up to us 

  		   to tell esock when to retry (by signalling with NewData(0)). If it was some error that we couldn't

  		   handle at all then we should have set the error upon the socket  	

*/

TInt CAvctpSap::GetData(RMBufChain& aData, TUint /*aLength*/, TUint /*aOptions*/, TSockAddr* aAddr)

	{

	LOG_FUNC

	// We've been asked to close so esock shouldn't be asking us for more data

	__ASSERT_ALWAYS(!iIsClosing, Panic(EUnexpectedEsockEvent));

	__ASSERT_DEBUG(!iClosed, Panic(EAvctpSapClosed));

	HAvctpIncomingSdu* sdu = iIncomingSdus.First();

	__ASSERT_ALWAYS(sdu, Panic(ENullPacket));

	aData.Assign(const_cast<RMBufChain&>(sdu->Data()));

	if (aAddr)

		{

		TAvctpSockAddr avctpAddr = TAvctpSockAddr::Cast(*aAddr);

		avctpAddr.SetPid(iPid);

		avctpAddr.SetBTAddr(sdu->BTAddr());

		avctpAddr.SetChannel(iChannel);

		(*aAddr) = avctpAddr;   // Convert back

		}	

	delete sdu; // deques pkt in ~HAvctpIncomingSdu				

	return KErrNone;	

	}

/**

Perform an Ioctl.

  @internalAll

  @param aLevel The Ioctl level

  @param aName The Ioctl name

  @param aOption The Ioctl data

*/

void CAvctpSap::Ioctl(TUint /*aLevel*/, TUint /*aName*/, TDes8* /*aOption*/)

	{

	LOG_FUNC

	Socket().Error(KErrNotSupported, MSocketNotify::EErrorIoctl);

	__ASSERT_DEBUG(NULL, Panic(EIoctlsNotSupported));

	}