// 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 <es_sock.h>
#include "avctppacket.h"
#include "avctpcommon.h"
#include "avctpmuxer.h"
#include "avctputils.h"
#include "avctpconstants.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_AVCTP);
#endif

#ifdef _DEBUG
PANICCATEGORY("avctppkt");
#endif

using namespace SymbianAvctp;

/*static*/ TPtrC8 CAvctpPacket::GetHeader(const RMBufChain& aChain)
	{
	const RMBuf* mbuf = aChain.First();
	// set the descriptor to read out the whole of the first mbuf (into which the header fits)
	return TPtrC8(mbuf->Ptr(), mbuf->Length());
	}


/**
Fills in the TAvctpHeaderInfo 

This function takes a TAvctpStartHeaderInfo rather than a TAvctpHeaderInfo to
avoid problems with casting from TAvctpHeaderInfo to TAvctpStartHeaderInfo & 
mangling data.

  @internalComponent
  @param aData The data buffer that contains the AVCTP packet to be parsed
  @param aHeaderInfo will contain the result of the parsing.
  @return KErrNone if there was no problem parsing the header, otherwise returns an 
  				   Avctp specific error.
*/
/*static*/ TInt CAvctpPacket::ParseHeader(const RMBufChain& aData, TAvctpStartHeaderInfo& aHeaderInfo)
	{
	LOG_STATIC_FUNC

	TInt err = KErrNone;
	
	// We require the packet to be long enough to at least contain the packet type
	const TPtrC8 dataP(GetHeader(aData));
	
	if (dataP.Length() < EMinimumHeaderLength)
		{
		err = KErrPacketTooShort;
		}
		
	if (err == KErrNone)
		{
		aHeaderInfo.iMsgType = SymbianAvctp::MessageType(dataP);
		aHeaderInfo.iTransactionLabel = SymbianAvctp::TransactionLabel(dataP);
		}

	// No checking needs to be done on the TAvctpHeaderInfo variables since
	// all values are allowed.
		
	// get the packet type		
	if (err == KErrNone)
		{
		aHeaderInfo.iPktType = SymbianAvctp::PacketType(dataP);
		switch (aHeaderInfo.iPktType)
			{
			case ENormalPkt:
				if (dataP.Length() < ENormalHeaderLength)
					{
					err = KErrPacketTooShort;
					}
				else 
					{
					err = ParseNormalHeader(dataP, aHeaderInfo);
					}
				break;
			case EStartFrag:
				if (dataP.Length() < EStartFragHeaderLength)
					{
					err = KErrPacketTooShort;
					}
				else 
					{
					err = ParseStartHeader(dataP, aHeaderInfo);									
					}
				break;
			case EContinueFrag:
			case EEndFrag:
				// the Size check before this switch statement ensures that
				// the given data is long enough since EOtherFragHeaderLength = 1
				break;
			default:
				err = KErrUnknownPacketType;
				break;
			}
		}	
	return err;
	}
	
/**
Fills in the TAvctpNormalHeaderInfo 
Assumes aData is at least ENormalHeaderLength long

  @internalComponent
  @param aData The data buffer that contains the AVCTP packet to be parsed
  @param aHeaderInfo will contain the result of the parsing.
  @return KErrNone if there was no problem parsing the header, otherwise returns an 
  				   Avctp specific error.
*/
/*static*/ TInt CAvctpPacket::ParseNormalHeader(const TDesC8& aData, TAvctpNormalHeaderInfo& aHeaderInfo)
	{
	LOG_STATIC_FUNC

	aHeaderInfo.iHasValidPid = IsValidPid(aData);
	aHeaderInfo.iPid = Pid(aData);
	return CheckNormalHeaderInfo(aHeaderInfo);
	}
	
/**
Fills in the TAvctpStartHeaderInfo 
Assumes aData is at least EStartFragHeaderLength long

  @internalComponent
  @param aData The data buffer that contains the AVCTP packet to be parsed
  @param aHeaderInfo will contain the result of the parsing.
  @return KErrNone if there was no problem parsing the header, otherwise returns an 
  				   Avctp specific error.
*/
/*static*/ TInt CAvctpPacket::ParseStartHeader(const TDesC8& aData, TAvctpStartHeaderInfo& aHeaderInfo)
	{
	LOG_STATIC_FUNC

	TInt err = ParseNormalHeader(aData, aHeaderInfo);
	if (err == KErrNone)
		{
		aHeaderInfo.iFragmentsInSdu = FragmentsInSdu(aData);
		err = CheckStartHeaderInfo(aHeaderInfo);
		}
		
	return err;
	}

/*
Checks the validity of a TAvctpNormalHeaderInfo object. Note that the variables
derived from TAvctpHeaderInfo cannot be incorrect since all values that might appear
in a air packet are allowed.

(NB the RFA field in Continue and End packets [the IPID field in other types of packet]
must be set to 0 in the AVCTP v1.0 spec. However, we don't enforce this on incoming
in case it is used in future.)
*/ 
/*static*/ TInt CAvctpPacket::CheckNormalHeaderInfo(const TAvctpNormalHeaderInfo& aHeaderInfo)
	{
	LOG_STATIC_FUNC

	ASSERT_DEBUG(aHeaderInfo.iPktType == ENormalPkt ||
		   aHeaderInfo.iPktType == EStartFrag);
		
	TInt ret = KErrNone;
	if (!aHeaderInfo.iHasValidPid && aHeaderInfo.iMsgType == ECommand)
		{
		ret = KErrMalformedPacketFromRemote;
		}
	return ret;
	}

/*
Checks the validity of a TAvctpStartHeaderInfo object. 
*/ 	
/*static*/ TInt CAvctpPacket::CheckStartHeaderInfo(const TAvctpStartHeaderInfo& aHeaderInfo)
	{
	LOG_STATIC_FUNC

	ASSERT_DEBUG(aHeaderInfo.iPktType == EStartFrag);
	
	TInt ret = KErrNone;
	if (aHeaderInfo.iFragmentsInSdu > 1)
		{
		ret = CheckNormalHeaderInfo(aHeaderInfo);
		}
	else
		{
		ret = KErrMalformedPacketFromRemote;
		}
		
	return ret;
	}
	

//
//                                                                                       //
// HAvctpOutgoingSdu Implementation                                                    //
//                                                                                       //
//

HAvctpOutgoingSdu* HAvctpOutgoingSdu::NewL(const TAvctpNormalHeaderInfo& aHeaderInfo,
							 			   const TBTDevAddr& aAddr,
					 		 			   RMBufChain& aData)
	{
	LOG_STATIC_FUNC

	HAvctpOutgoingSdu* sdu = new(ELeave) HAvctpOutgoingSdu(aHeaderInfo, aAddr);
	CleanupStack::PushL(sdu);
	sdu->ConstructL(aData);
	CleanupStack::Pop(sdu);
	return sdu;
	}

/** 
Create the buffer by copying over the other descriptor allowing space for a header
at the beginning
*/	
void HAvctpOutgoingSdu::ConstructL(RMBufChain& aData)
	{
	LOG_FUNC
	iSduData.Assign(aData);
	}

HAvctpOutgoingSdu* HAvctpOutgoingSdu::NewIpidResponseL(const HAvctpIncomingSdu& aIncomingSdu, TInt aChannel)
	{
	LOG_STATIC_FUNC
	
	TPtrC8 hdr(CAvctpPacket::GetHeader(aIncomingSdu.Data()));
	
	LOG1(_L("to Pid 0x%x"), Pid(hdr));
	
	TAvctpNormalHeaderInfo headerInfo = 
		TAvctpNormalHeaderInfo(TransactionLabel(hdr),
							   ENormalPkt,
							   EResponse,
							   EFalse,
							   Pid(hdr)
							   );

	HAvctpOutgoingSdu* sdu = new(ELeave) HAvctpOutgoingSdu(headerInfo, aIncomingSdu.BTAddr());
	sdu->iChannel = aChannel;
	
	return sdu;
	}
				
HAvctpOutgoingSdu::~HAvctpOutgoingSdu()
	{
	LOG_FUNC

	iSduData.Free();
	
	if (iOutboundQ)
		{
		iOutboundQ->Deque(*this);
		}
	else
		{
		iQueLink.Deque();	
		}
	}