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

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include <bluetoothav.h>

#include <es_mbuf.h>

#include "avctpPacketMgr.h" 

#include "Avctp.h"

#include "avctpmuxer.h"

#include "avctpconstants.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVCTP);

#endif

using namespace SymbianAvctp;

/**

Static factory function for an AVCTP Packet Manager

  @internalComponent

  @leave KErrNoMemory if the new packet could not be allocated

  @return A pointer to an AVCTP Packet Manager

*/

CAvctpPacketMgr* CAvctpPacketMgr::NewL(CAvctpTransport& aMuxer,

										CAvctpProtocol& aProtocol)

	{

	LOG_STATIC_FUNC

	CAvctpPacketMgr* mgr = new(ELeave) CAvctpPacketMgr(aMuxer, aProtocol);

	CleanupStack::PushL(mgr);

	mgr->ConstructL();

	CleanupStack::Pop(mgr);

	return mgr;	

	}

void CAvctpPacketMgr::ConstructL()

	{

	LOG_FUNC

	iIncomingAssemblers[KAvctpPrimaryChannel] = CIncomingSduAssembler::NewL(*this,0);

	iOutgoingFragmenters[KAvctpPrimaryChannel] = COutgoingSduFragmenter::NewL(*this,0);	

	iIncomingAssemblers[KAvctpSecondaryChannel] = CIncomingSduAssembler::NewL(*this,1);

	iOutgoingFragmenters[KAvctpSecondaryChannel] = COutgoingSduFragmenter::NewL(*this,1);	

	}

/**

Default constructor for an AVCTP Packet Manager

  @internalComponent

*/

CAvctpPacketMgr::CAvctpPacketMgr(CAvctpTransport& aTransport, CAvctpProtocol& aProtocol)

	: iTransport(aTransport),

	  iProtocol(aProtocol)

	{

	LOG_FUNC

	}

/**

Default destructor for an AVCTP Packet Manager

  @internalComponent

*/

CAvctpPacketMgr::~CAvctpPacketMgr()

	{

	LOG_FUNC

	delete iIncomingAssemblers[0];

	delete iOutgoingFragmenters[0];

	delete iIncomingAssemblers[1];

	delete iOutgoingFragmenters[1];

	}

/**

Transfers ownership of the aOutgoingSdu to CAvctpPacketMgr if the write succeeded

i.e. didn't return 0

Note this function should not be used by other classes to send IPID responses. 

Use WriteIpid for this instead.

*/

void CAvctpPacketMgr::Write(HAvctpOutgoingSdu*& aOutgoingSdu, TInt aChannel)

	{

	LOG_FUNC

	iOutgoingFragmenters[aChannel]->Write(aOutgoingSdu);

	}

/**

This functions

Transfers ownership of the aOutgoingSdu to CAvctpPacketMgr if the write succeeded

i.e. didn't return 0

Note this function should only be used to send IPID responses. Use Write for all other

Sdus instead.

*/

TInt CAvctpPacketMgr::WriteIpid(HAvctpOutgoingSdu*& aOutgoingSdu)

	{

	LOG_FUNC

	Write(aOutgoingSdu, aOutgoingSdu->Channel());

	TInt ret = KErrNone;

	if (!aOutgoingSdu)

		{

		++iIpidSdusSent;

		LOG1(_L("Sent %d IPID responses"), iIpidSdusSent);

		if (iIpidSdusSent >= KMaximumIpidResponsesAllowed)

			{

			ret = KErrRemoteSentTooManyIpidSdus;

			}

		}

	else

		{

		ret = KErrMuxerBlocked;	// if the sdu is not null means it hasn't been sent.

		}

	return ret;

	}

/** 

This is the lower protocol notifying us it can now send more data

We check to see if we were in the middle of sending fragments and

if so we write all those we can.

@return EFalse if we've blocked the muxer o/w EFalse

*/

void CAvctpPacketMgr::CanSend(TInt aChannel)

	{

	LOG_FUNC

	iOutgoingFragmenters[aChannel]->CanSend();

	}

/**

We don't pass on the send / recv errors to the saps

because these errors only concern the packets we've

tried to send over L2CAP.

We don't do anything on fatal errors cause the muxer 

goes down in that situation and takes the packet mgr

with it.

*/

void CAvctpPacketMgr::SignalMuxerError(TInt /*aError*/,TUint aOperationMask)

	{

	LOG_FUNC

	if (aOperationMask & (MSocketNotify::EErrorSend))

		{

		iIncomingAssemblers[KAvctpPrimaryChannel]->Reset();

		iIncomingAssemblers[KAvctpSecondaryChannel]->Reset();

		}

	if (aOperationMask & (MSocketNotify::EErrorRecv))

		{

		iOutgoingFragmenters[KAvctpPrimaryChannel]->Reset();

		iOutgoingFragmenters[KAvctpSecondaryChannel]->Reset();

		}

	}

/**

This function transfers the ownership of aIncomingPdu from the

muxer to CAvctpPacketMgr

*/ 

TInt CAvctpPacketMgr::NewData(RMBufChain& aIncomingPdu, TInt aChannel)

	{

	LOG_FUNC

	TAvctpStartHeaderInfo headerInfo;

	TInt err = CAvctpPacket::ParseHeader(aIncomingPdu, headerInfo);

	if (err == KErrNone)

		{

		TRAP(err, iIncomingAssemblers[aChannel]->AddDataL(headerInfo, aIncomingPdu)); // transfers ownership of aIncomingPdu on success 

		if (err != KErrNone)

			{

			// We've OOM'd so drop packet

			aIncomingPdu.Free();

			// Don't reset iIncomingAssembler since it'll reset itself on 

			// the next start or normal packet if we missed a vital fragment here

			}

		err=KErrNone; //Want to read remaining packets, so don't pass an error back up.

		}

	else

		{

		// There was something wrong with the PDU so punish the remote

		Transport().Shutdown(err);

		aIncomingPdu.Free();

		err = KErrMuxerShutDown;

		}

	return err;

	}

TBool CAvctpPacketMgr::WouldLikeToSend()

	{

	return iOutgoingFragmenters[KAvctpPrimaryChannel]->HasData() || iOutgoingFragmenters[KAvctpSecondaryChannel]->HasData();  

	}

//

//

// implementation of COutgoingSduFragmenter

//

//

/**

Default constructor for an outgoing partial AVCTP Sdu

  @internalComponent

*/

COutgoingSduFragmenter::COutgoingSduFragmenter(CAvctpPacketMgr& aMgr, TInt aChannel)

	: iMgr(aMgr), iChannel(aChannel)

	{

	LOG_FUNC

	}

/**

Static factory function

  @internalComponent

  @leave KErrNoMemory if the new packet could not be allocated

  @return A pointer to an outgoing partial AVCTP Sdu

*/

COutgoingSduFragmenter* COutgoingSduFragmenter::NewL(CAvctpPacketMgr& aMgr, TInt aChannel)

	{

	LOG_STATIC_FUNC

	COutgoingSduFragmenter* packet = new(ELeave) COutgoingSduFragmenter(aMgr, aChannel);

	CleanupStack::PushL(packet);

	packet->ConstructL();

	CleanupStack::Pop(packet);

	return packet;

	}	

void COutgoingSduFragmenter::ConstructL()

	{

	LOG_FUNC

	TCallBack cb(SendAsyncCallBack, this);

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

	}

COutgoingSduFragmenter::~COutgoingSduFragmenter()

	{

	LOG_FUNC

	delete iSendAsyncCallBack;

	}	

void COutgoingSduFragmenter::Reset()

	{

	LOG_FUNC

	iSduData.Free();

	iCurrentWriteState = ENormal;

	// we don't have anymore data to send, so check for idle so that if the transport is idle, the 

	// timer will be set and when expires it will be destroyed.

	iMgr.Transport().CheckForIdle();

	}

TBool COutgoingSduFragmenter::HasData()

	{

	return iSduData.Length() > 0;

	}

/**

If we can take ownership of this we do, and kick off async send.  Otherwise

we do nothing and the SDU remains on the caller's queue.

*/

void COutgoingSduFragmenter::Write(HAvctpOutgoingSdu*& aOutgoingSdu)

	{

	LOG_FUNC

	if (iSduData.Length() == 0)

		{

		iSduData.Assign(aOutgoingSdu->Data());

		iAddr = aOutgoingSdu->BTAddr();

		iHeaderInfo = aOutgoingSdu->HeaderInfo();

		delete aOutgoingSdu;

		aOutgoingSdu = NULL;

		StartSendAsyncCallBack();

		}

	}

TInt COutgoingSduFragmenter::CountFragments(const RMBufChain& aSdu, TInt iMtuUsedToFragment) const

	{

	TUint totalFragmentsNeeded = 1;

	if (aSdu.Length() + ENormalHeaderLength > iMtuUsedToFragment)

		{

		TInt dataRemaining = aSdu.Length() + EStartFragHeaderLength

									 - iMtuUsedToFragment;

		while (dataRemaining > 0)

			{

			totalFragmentsNeeded++;

			dataRemaining -= (iMtuUsedToFragment - EOtherFragHeaderLength);

			}

		}

	return totalFragmentsNeeded;

	}

void COutgoingSduFragmenter::DoSendCurrentSDU()

	{

	// we should have one fragmenter allowed to write to a given remote at any time

	// once the fragmenter has done its job then we can ask the SAPs to drain an SDU into the fragger

	TInt mtu = iMgr.Transport().GetCurrentOutboundMtu(iChannel);

	// If we couldn't retrieve the MTU we aren't in a state where we can send.

	// Once we are send should be kicked off by mux calling CanSend().

	if(mtu > 0)

		{

		switch(iCurrentWriteState)

			{

			case ENormal:

				{

				BeginSendingSdu(mtu);

				break;

				}

			case EFragmenting:

				{

				ContinueSendingSdu(mtu);

				break;

				}

			default:

				__ASSERT_DEBUG(EFalse, Panic(EAvctpInvalidFragmenterState));

			};

		}

	}

void COutgoingSduFragmenter::BeginSendingSdu(TInt aMtu)

	{

	LOG_FUNC

	__ASSERT_DEBUG(iCurrentWriteState == COutgoingSduFragmenter::ENormal, Panic(EAvctpInvalidFragmenterState));

	RMBufChain pdu;

	TInt numberFragments = 1;

	if (aMtu >= iSduData.Length() + ENormalHeaderLength)

		{

		pdu.Assign(iSduData);

		}

	else

		{

		numberFragments = CountFragments(iSduData, aMtu);

		pdu.Assign(iSduData);

		__DEBUG_ONLY(TInt err =) pdu.Split(aMtu - EStartFragHeaderLength, iSduData);

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

		}

	iHeaderInfo.iPktType = (iSduData.Length()) ? EStartFrag : ENormalPkt;

	if (AddHeader(pdu, numberFragments) == KErrNone)

		{

		if (iMgr.Transport().DoWrite(pdu,iChannel))

			{

			if(iSduData.Length() == 0)

				{

				Reset();

				}

			else

				{

				iCurrentWriteState = COutgoingSduFragmenter::EFragmenting;

				}

			CheckForCanSend();

			}

		else

			{

			pdu.Remove();	// remove the first RMBuf (that is the header)

			iSduData.Prepend(pdu); // put back the pdu in the iSduData

			}

		}

	else

		{

		LOG(_L("Error creating the header because KErrNoMemory"));

		__ASSERT_DEBUG(!pdu.IsEmpty(), Panic(EAvctpFragmenterEmptyPdu));

		pdu.Free();

		Reset();

		}

	__ASSERT_DEBUG(pdu.IsEmpty(), Panic(EAvctpFragmenterNonEmptyPdu));

	}

void COutgoingSduFragmenter::ContinueSendingSdu(TInt aMtu)

	{

	RMBufChain pdu;

	// if the data payload plus the header fit in the mtu then we can send all the iSduData content 

	if (aMtu >= iSduData.Length() + EOtherFragHeaderLength)

		{

		pdu.Assign(iSduData);

		}

	// we need to split iSduData as it is bigger than the mtu

	else

		{

		pdu.Assign(iSduData);

		__DEBUG_ONLY(TInt err =) pdu.Split(aMtu - EOtherFragHeaderLength, iSduData);

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

		}

	// pdu now containts either the whole remainend sdu data (first if branch) or a bit of it (second branch)

	// and iSduData contains either nothing or the remained sdu payload. Based on its length we know the packet type

	// we are going to send.

	iHeaderInfo.iPktType = (iSduData.Length()) ? EContinueFrag : EEndFrag;

	if (AddHeader(pdu, 1) == KErrNone)

		{

		if (iMgr.Transport().DoWrite(pdu,iChannel))

			{

			if(iSduData.Length() == 0)

				{

				Reset();

				}

			CheckForCanSend();

			}

		else

			{

			pdu.Remove();	// remove the first RMBuf (that is the header)

			iSduData.Prepend(pdu); // put back the pdu in the iSduData

			}

		}

	else

		{

		LOG(_L("Error creating the header because KErrNoMemory"));

		__ASSERT_DEBUG(!pdu.IsEmpty(), Panic(EAvctpFragmenterEmptyPdu));

		pdu.Free();

		Reset();

		}

	__ASSERT_DEBUG(pdu.IsEmpty(), Panic(EAvctpFragmenterNonEmptyPdu));

	}

TInt COutgoingSduFragmenter::AddHeader(RMBufChain& aPdu, TInt aNumFragments)

	{

	TInt headerLength = 0;

	switch(iHeaderInfo.iPktType)

		{

		case ENormalPkt:

			headerLength = ENormalHeaderLength;

			break;

		case EStartFrag:

			headerLength = EStartFragHeaderLength;

			break;

		case EContinueFrag:

		case EEndFrag:

			headerLength = EOtherFragHeaderLength;

			break;

		default:

			__ASSERT_DEBUG(EFalse, Panic(EAvctpFragmenterInvalidHeaderType));

		}

	RMBuf* header = RMBuf::Alloc(headerLength);

	if (header)

		{

		TUint8& avctpHeaderByte = *(header->Ptr());

		avctpHeaderByte = 0;

		// Check the transaction label is valid

		AssertValidTransactionLabel(iHeaderInfo.iTransactionLabel);

		avctpHeaderByte |= iHeaderInfo.iTransactionLabel << KTransactionLabelShift;

		avctpHeaderByte |= iHeaderInfo.iPktType << KPacketTypeShift;

		if (iHeaderInfo.iMsgType == SymbianAvctp::EResponse)

			{

			avctpHeaderByte |= KResponseMsgBit;

			}

		if(iHeaderInfo.iPktType == ENormalPkt)

			{

			BigEndian::Put16(header->Ptr()+KNormalHeaderPidOffset,iHeaderInfo.iPid);

			}

		else if(iHeaderInfo.iPktType == EStartFrag)

			{

			*(header->Ptr() + KNumFragmentsOffset) = aNumFragments;

			BigEndian::Put16(header->Ptr()+KStartHeaderPidOffset,iHeaderInfo.iPid);

			}

		if (!iHeaderInfo.iHasValidPid)

			{

			avctpHeaderByte |= KIsValidPidMask;

			}

		aPdu.Prepend(header);

		}

	return header ? KErrNone : KErrNoMemory;

	}

void COutgoingSduFragmenter::CanSend()

	{

	LOG_FUNC

	// If we have Sdu left to send this will kick off an async send, else

	// it will signal to SAPs that we are ready to receive more data

	CheckForCanSend();

	}

/*static*/ TInt COutgoingSduFragmenter::SendAsyncCallBack(TAny* aFragmenter)

	{

	static_cast<COutgoingSduFragmenter*>(aFragmenter)->DoSendCurrentSDU();

	return KErrNone;

	}

void COutgoingSduFragmenter::StartSendAsyncCallBack()

	{

	iSendAsyncCallBack->CallBack();

	}

void COutgoingSduFragmenter::CancelSendAsyncCallBack()