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

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include "avdtpSignallingMessages.h"

#include "avdtpSignallingChannel.h"

#include "avdtputil.h"

#include "avdtp.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);

#endif

using namespace SymbianBluetoothAV;

CAvdtpSignallingMessage::CAvdtpSignallingMessage()

	{

	LOG_FUNC

	Data().Init();

	}

CAvdtpInboundSignallingMessage::CAvdtpInboundSignallingMessage(CSignallingChannel& aSignallingChannel)

: iSignallingChannel(aSignallingChannel)

	{

	LOG_FUNC

	}

/*static*/ void CAvdtpOutboundSignallingMessage::PrependSignallingHeaderL(

									RMBufChain& aDest,

									const TAvdtpPacketType& aPacketType,

									const TAvdtpTransactionLabel& aTransLabel,

									const TAvdtpMessageType& aMessageType,

									TAvdtpMessage aSigId,

									TInt aNumberSignalPackets)

	{

	LOG_STATIC_FUNC

	RMBuf& header = *RMBuf::AllocL();

	aDest.Prepend(&header);

	TUint8	firstByte = 

		((aTransLabel<<KAvdtpTransactionLabelOffset) & KAvdtpTransactionLabelMask) |

		((aPacketType<<KAvdtpPacketTypeOffset)		 & KAvdtpPacketTypeMask)       |

		((aMessageType<<KAvdtpMessageTypeOffset)	 & KAvdtpMessageTypeMask);

	switch (aPacketType)

		{

		case ESingle:

			{

			header.SetLength(KAvdtpMinimumSignallingSinglePacketLength);

			TUint8 lastByte = ((aSigId) & KAvdtpSignalIdentifierMask);

			header.Put(firstByte,0);

			header.Put(lastByte,1);

			break;

			}

		case EStart:

			{

			header.SetLength(KAvdtpMinimumSignallingStartPacketLength);

			TUint8 lastByte = ((aSigId) & KAvdtpSignalIdentifierMask);

			header.Put(firstByte,0);

			header.Put(static_cast<TUint8>(aNumberSignalPackets),1);

			header.Put(lastByte,2);

			break;

			}

		case EEnd:

		case EContinue:

			header.SetLength(KAvdtpMinimumSignallingContinuePacketLength);

			header.Put(firstByte,0);

			break;			

		}	

	}

/*

Return True if more fragments in packet

*/

TBool CAvdtpOutboundSignallingMessage::GetNextOutboundFragmentL(RMBufChain& aDest, TInt aMaxSize)

	{

	LOG_FUNC

	TAvdtpPacketType pktType;

	if (!iFragInfo.iFragmented)

		{

		// no fragmentation already done - might be single or need fragmenting

		__ASSERT_DEBUG(Data().Length()<=(0xff*aMaxSize), Panic(EAvdtpBadlyFormattedOutboundSignallingMessage));

		if ((Data().Length()+

			KAvdtpMinimumSignallingSinglePacketLength) < aMaxSize)

			{

			//no fragmentation required

			PrependSignallingHeaderL(Data(),ESingle,TransactionLabel(),iMessageType,Signal());

			aDest.Assign(Data()); //transfer ownership of Data to aDest

			Deque();	// remove this from the outbound queue

			return EFalse; //no more frags - returned whole packet

			}

		else

			{

			// Start fragment(ing)

			//we can get MTU-3 bytes in the first pkt, MTU-1 in the rest

			//just pretend it's 2 bytes longer than it is and divide by

			//MTU - 1 

			iFragInfo.iTotalPackets = ((Data().Length()+2)/(aMaxSize-1));

			//and add one if it wasn't an exact fit

			if ((Data().Length()+2)%(aMaxSize-1))

				{

				iFragInfo.iTotalPackets++;

				}

			iFragInfo.iPacketNumber=0;

			iFragInfo.iFragmented=ETrue;

			pktType = EStart;

			}

		}

	else

		{

		// continue and end parts

		pktType = (iFragInfo.iPacketNumber<(iFragInfo.iTotalPackets-1)) ? EContinue : EEnd;

		}

	PrependSignallingHeaderL(Data(), pktType, TransactionLabel(), iMessageType,

							 Signal(), iFragInfo.iTotalPackets);

	// copy into "fragment" (whole packet if Single!) amount of message that will fit

	// the message here doesn't have the header, but we do know we need to fragment

	// (MTU-3) for Start, (MTU-1) for Continue,End

	TInt size = 0;

	switch (pktType)

		{

		case EStart:

		size = aMaxSize - KAvdtpMinimumSignallingStartPacketLength;

		break; 

		case EContinue:

		size = aMaxSize - KAvdtpMinimumSignallingContinuePacketLength;

		break;

		case EEnd:

		size = aMaxSize - KAvdtpMinimumSignallingEndPacketLength;

		break;

		case ESingle: // drop through

		default:

		__ASSERT_DEBUG(0, Panic(EAvdtpBadlyFormattedOutboundSignallingMessage));

		}

	Data().CopyL(aDest,0,size);

	// and trim off the copied data from Data()

	// esock workaround - panic if trim > size of chain

	Data().TrimStart(Min(size, Data().Length()));

	if (iFragInfo.iPacketNumber++==iFragInfo.iTotalPackets)

		{

		// all fragments done

		Deque();

		return EFalse; // no more fragments from this packet

		}

	return ETrue;

	}

/**

Check that packet header is ok for the packet build state we're in

@param aFragment the next incoming fragment to validate

@return KErrNone if ok, KErrCorrupt if not. KErrAbort if fragment is an Abort packet

*/

TInt CAvdtpInboundSignallingMessage::CheckPacketType(RMBufChain& aFragment, TAvdtpPacketType& aPacketType, TAvdtpMessageType& aMessageType, TAvdtpTransactionLabel& aTransactionLabel)

	{

	LOG_FUNC

	 //NB could be an Abort packet interleaved in building up the previous packet

	TInt ret = KErrCorrupt;

	if (aFragment.First())

		{

		TAvdtpPacketType packetType = static_cast<TAvdtpPacketType>((aFragment.First()->Ptr()[0] & KAvdtpPacketTypeMask) >> KAvdtpPacketTypeOffset);

		TAvdtpMessageType messageType = static_cast<TAvdtpMessageType>((aFragment.First()->Ptr()[0] & KAvdtpMessageTypeMask) >> KAvdtpMessageTypeOffset);

		TAvdtpTransactionLabel transactionLabel = static_cast<TAvdtpTransactionLabel>((aFragment.First()->Ptr()[0] & KAvdtpTransactionLabelMask) >> KAvdtpTransactionLabelOffset);

		aMessageType = messageType;

		aTransactionLabel = transactionLabel;

		aPacketType = packetType;

		/* check if an abort has come in

			The abort will be a single packet type

			The message type will be a command

			The indication (second byte) will EAvdtpAbort

		  if an abort has come in then return KErrAbort and

		  the abort will be correctly processed. The packetbuildstate will 

		  be reset to EAwaitingNew

		  */

		if ((ESingle == packetType) && (ECommand == messageType))

			{

			/* note that when checking for the signal identifier HERE

			   we haven't yet removed the first byte from the message

			 */

			if (aFragment.First()->Size() > 1)

				{

				TAvdtpMessage id = static_cast<TAvdtpMessage>(aFragment.First()->Ptr()[1] & KAvdtpSignalIdentifierMask);

				if (EAvdtpAbort == id)

					{

					return (KErrAbort);

					}

				}

			}

		switch (iPacketBuildState)

			{

			case EAwaitingNew:

				// if waiting for a new packet then packet type must be single or start

				if ((packetType==ESingle)||(packetType==EStart))

					{

					ret=KErrNone;

					}

				break;

			case EAwaitingContinue:

				// if waiting for continue then type must be continue, and the transaction label

				// of this fragment must match the packet we're building. Ditto for message type

				if ((packetType==EContinue) && 

				    (transactionLabel==iPacketBuildLabel) && 

				    (messageType==iMessageType))

					{

					ret=KErrNone;

					}

				break;

			case EAwaitingEnd:

				// if waiting for end then type must be end, and the transaction label

				// of this fragment must match the packet we're building. Ditto for message type			

				if ((packetType==EEnd) && 

				    (transactionLabel==iPacketBuildLabel) && 

				    (messageType==iMessageType))

				    {

				    ret=KErrNone;

				    }

				break;

			}

		}

	return ret;

	}

void CAvdtpSignallingMessage::SetType(TAvdtpMessageType aType,TAvdtpMessage aMessage)

	{

	LOG_FUNC

	iSignal = aMessage;

	iMessageType = aType;

	}

CAvdtpOutboundSignallingMessage::~CAvdtpOutboundSignallingMessage()

	{

	LOG_FUNC

	if (iMessageType==ECommand)

		{

		//OutBound Signalling message should never be EReserved

		__ASSERT_DEBUG(Signal()!= EReserved,Panic(EAvdtpInvalidReservedValueInOutboundSignallingMessage));

		iCommandLabel.Close();

		}

	Deque();

	}

void CAvdtpOutboundSignallingMessage::AddSEPInfoL(const TAvdtpSEPInfo& aSEPInfo)

	{

	LOG_FUNC

	// append SEP info to packet

	TBuf8<KAvdtpPacketSEPInfoSize> SEPInfoBuf;

	SEPInfoBuf.SetMax();

	SEPInfoBuf[0] = aSEPInfo.SEID().PacketValue();

	if (aSEPInfo.InUse())

		{

		SEPInfoBuf[0]|=(1<<KAvdtpInUseFlagOffset);

		}

	SEPInfoBuf[1] = aSEPInfo.MediaType()<<KAvdtpMediaTypeOffset;

	if (aSEPInfo.IsSink())

		{

		SEPInfoBuf[1]|=(1<<KAvdtpTSEPOffset);

		}

	AppendDataL(SEPInfoBuf);

	}

void CAvdtpOutboundSignallingMessage::AddSEPCapabilityL(const TAvdtpServiceCapability& aCapability)

	{

	LOG_FUNC

	// append SEP capability to packet, this temp buffer *cannot* be placed on cleanupstack (it may get reallocated)

	RBuf8 buf;

	buf.CreateL(KAvdtpServiceCapabilitiesHeaderLen);

	buf.CleanupClosePushL();

	User::LeaveIfError(aCapability.AsProtocol(buf));	

	AppendDataL(buf);

	buf.Close();

	CleanupStack::Pop();

	}

void CAvdtpOutboundSignallingMessage::Deque()

	{

	LOG_FUNC

	iLink.Deque();

	}

TInt CAvdtpOutboundSignallingMessage::AllocateTransactionLabel(TTransactionLabelManager& aManager)

	{

	LOG_FUNC

	return aManager.GetLabel(iCommandLabel);

	}

void CAvdtpOutboundSignallingMessage::SetTransactionLabel(TAvdtpTransactionLabel aLabel)

	{

	LOG_FUNC

	iResponseLabel = aLabel;

	}

TInt CAvdtpOutboundSignallingMessage::NewData(TUint /*aCount*/)	

	{

	Panic(EAvdtpOutboundMessageNewDataCalled);

	return KErrNotSupported;

	}

/**

Upcall from signalling channel telling us of new inbound data

The data is synchronously retrieved, checked and added to the building packet

Once the packet is complete the packet begins parsing

*/	

/*virtual*/ TInt CAvdtpInboundSignallingMessage::NewData(TUint aCount)

	{

	LOG_FUNC

	RMBufChain fragment;

	TInt result = KErrNone;

	while (aCount--)

		{

		result = iSignallingChannel.GetData(fragment,NULL);

		if (result<KErrNone)

			{

			break;

			}

		TAvdtpPacketType packetType;

		TAvdtpMessageType messageType;

		TAvdtpTransactionLabel transactionLabel;

		// check the AVDTP Packet type part of the header	

		result = CheckPacketType(fragment, packetType, messageType, transactionLabel);

   		if (result == KErrAbort)

   			{

 			// if the packet build state is other than awaiting new then

 			// we have some existing data to throw out (the abort should discard)

 			if (iPacketBuildState != EAwaitingNew)

 				{

 				Data().Free(); 		//drop

 				}

 			// reset the packet build state so that we process the abort.

 			iPacketBuildState = EAwaitingNew;

   			// clear current message??

   			// at moment do nothing - mayneed to parse to see if it's the same SEID - yuk protocol

   			result = KErrNone; // will actually process the Abort message

   			}

		// if the packet type is ok then it can be added into the building up packet

		if (result == KErrNone)

			{

			iFragmentationInfo.iPacketNumber++;

			// see whether to start new packet

			switch (iPacketBuildState)

				{

				case EAwaitingNew:

					// can see what this message is going to be

					iMessageType = messageType;

					TRAP(result,Data() = MessageL(fragment,packetType));

					if (result==KErrNone)

						{

						iPacketBuildLabel = transactionLabel;

						if (packetType==ESingle)

							{

							// and can now process - no more to wait for!

							Process(iPacketBuildLabel);

							// reset the packet number counter

							iFragmentationInfo.iPacketNumber =0;

							}

						else

							{

							// a start, data remembered above, and hold off processing

							iFragmentationInfo.iFragmented = ETrue;

							iFragmentationInfo.iTotalPackets = NumberSignalPackets(fragment);

							iPacketBuildState = EAwaitingContinue;

							}

						}

					break;

				case EAwaitingContinue:

					{

					// check that the number of packets < NOSP

					result = iFragmentationInfo.iFragmented &&

								(iFragmentationInfo.iPacketNumber < iFragmentationInfo.iTotalPackets)

								? KErrNone : KErrNotReady;

					if (result==KErrNone)

						{

						RMBufChain message;

						TRAP(result,message = MessageL(fragment,packetType));

						if (result==KErrNone)

							{

							// add into forming packet

							Data().Append(message);

							// see if we expect End next

							if (iFragmentationInfo.iPacketNumber == iFragmentationInfo.iTotalPackets-1)

								{

								iPacketBuildState = EAwaitingEnd;

								}

							}

						}

					}

					break;

				case EAwaitingEnd:

					{

					// check that the number of packets == NOSP

					result = iFragmentationInfo.iFragmented &&

								(iFragmentationInfo.iPacketNumber == iFragmentationInfo.iTotalPackets)

								? KErrNone : KErrNotReady;

					if (result==KErrNone)

						{

						RMBufChain message;

						TRAP(result,message = MessageL(fragment,packetType));

						if (result==KErrNone)

							{

							// add into forming packet

							Data().Append(message);

							// and process cos no more to come

							Process(iPacketBuildLabel);

							iPacketBuildState = EAwaitingNew;

							}

						}

					}

					break;

				}

			}

		else

			{

			//drop - free'd below

			}

		// all done with the inbound fragment

		fragment.Free();	

		}

	return result;

	}

/**

Begin processing the complete packet

*/

void CAvdtpInboundSignallingMessage::Process(TAvdtpTransactionLabel aLabel)

	{

	LOG_FUNC

	iSignal = SignalIdentifier(Data());

	// member function pointer

	// the handlers have no policy - they just parse and generate indications to SAP

   	void (*handler)(CAvdtpInboundSignallingMessage&, TAvdtpTransactionLabel);

	switch (Signal())

		{

		case EAvdtpDiscover:

			handler = HandleDiscoverL;

			break;

		case EAvdtpGetCapabilities:

			handler = HandleGetCapsL;

			break;

		case EAvdtpSetConfiguration:

			handler = HandleSetConfigL;

			break;

		case EAvdtpGetConfiguration:

			handler = HandleGetConfigL;

			break;

		case EAvdtpReconfigure:

			handler = HandleReconfigL;

			break;

		case EAvdtpOpen:

			handler = HandleOpenL;

			break;

		case EAvdtpStart:

			handler = HandleStartL;

			break;

		case EAvdtpRelease:

			handler = HandleReleaseL;

			break;

		case EAvdtpSuspend:

			handler = HandleSuspendL;

			break;

		case EAvdtpAbort:

			handler = HandleAbortL;

			break;

		case EAvdtpSecurityControl:

			handler = HandleSecurityControlL;

			break;

		case EReserved:

			Data().Free(); 		//drop

			iPacketBuildState = EAwaitingNew;

			return;

		default:

			{

			if(iMessageType==ECommand)

				{

				iSignallingChannel.SendReject(aLabel, Signal(), EAvdtpNotSupportedCommand/*ignored*/);

				}