// Copyright (c) 2000-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:
// dataparser.cpp - all the sdp parser code
// 
//

#include <bluetooth/logger.h>
#include <btsdp.h>
#include "sdpconsts.h"
#include "sdputil.h"

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

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

static const TInt KLinBufSizeLimit = 0x800;	// 2K

CElementParser::CLinearBuf* CElementParser::CLinearBuf::NewLC(TInt aExpandSize)
/** Element parser constructor. */
	{
	CLinearBuf* self = new(ELeave) CLinearBuf;
	CleanupStack::PushL(self);
	self->ConstructL(aExpandSize);
	return self;
	}

CElementParser::CLinearBuf::~CLinearBuf()
	{
	delete iBuf;
	}

void CElementParser::CLinearBuf::AppendL(const TDesC8& aData)
/** Add aData onto the end of this linear buffer.*/
	{
	if (iStartOffset && aData.Length() / 4 > Size())
		{// Might as well shuffle the buffer up now
		iBuf->Delete(0, iStartOffset);
		iStartOffset = 0;
		}
	iBuf->InsertL(iBuf->Size(), aData, aData.Length());
	}

const TPtrC8 CElementParser::CLinearBuf::Ptr() const
/** Get a constant Ptr to the contents of this buffer.*/
	{
	return iBuf->Ptr(iStartOffset);
	}

void CElementParser::CLinearBuf::Consume(TInt aLength)
/** Consume the first aLength bytes of the buffer.

	Optimised to avoid copies and heap operations on
	frequent calls to this function.*/
	{
	ASSERT_DEBUG(aLength <= Size());
	iStartOffset += aLength;
	if (iStartOffset > iBuf->Capacity() / 2 || Size() == 0)
		{// Actaully delete the stuff
		iBuf->Delete(0, iStartOffset);
		iStartOffset = 0;
		if (iBuf->Capacity() > KLinBufSizeLimit)
			{// Won't leave as we're reducing the reserve.
			TInt err;
			TRAP(err,iBuf->SetReserveL(Max(iBuf->Size(), KLinBufSizeLimit)));
			ASSERT_DEBUG(err == KErrNone);
			}
		}
	}

inline TInt CElementParser::CLinearBuf::Size() const
	{
	return iBuf->Size() - iStartOffset;
	}

CElementParser::CLinearBuf::CLinearBuf()
	{
	}

void CElementParser::CLinearBuf::ConstructL(TInt aExpandSize)
	{
	iBuf = CBufFlat::NewL(aExpandSize);
	}



CElementParser::CElementParser(MSdpElementBuilder* aBuilder)
	: iBuilder(aBuilder)
	{
	}

EXPORT_C CElementParser* CElementParser::NewL(MSdpElementBuilder* aBuilder)
/** Allocates and constructs a new CElementParser object.

@param aBuilder Object into which to build data element
@return New CElementParser object */
	{
	CElementParser* self = new(ELeave) CElementParser(aBuilder);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CElementParser::ConstructL()
	{
	this->iListStack = new(ELeave) CSdpStackFix<TInt>;
	}

EXPORT_C CElementParser::~CElementParser()
/** Destructor. */
	{
	delete iListStack;
	}


TBool CElementParser::IsComposite(TUint8 aType)
	{
	return aType == ETypeDES || aType == ETypeDEA;
	}

EXPORT_C TInt CElementParser::ParseElementsL(const TDesC8& aData)
/** Parses a data buffer into the currently set MSdpElementBuilder interface.

If a whole number of data elements can not be parsed out of aData, the number 
of bytes left unparsed is returned. Those bytes should be prepended to the 
buffer when the function is next called. 

@param aData Buffer to parse
@return Number of bytes not consumed */
	{
	TUint8* ptr = (TUint8*)aData.Ptr();
	const TUint8* ptrE = ptr + aData.Length();

	CloseListsL();
	while ((ptr < ptrE) && (iBuilder != NULL))
		{

		// Remember start of this data element
		TUint8* ptrStart = ptr;

		// We know there's at least one byte already..
		TUint8 type = (TUint8)(*ptr>>KSdpElemHdrTypeShift);
		TUint8 sizedesc  = (TUint8)(*ptr&KSdpElemHdrSizeMask);
		++ptr;

		if ( type >= sizeof(KSdpElementValidSizes) ||
			 !(KSdpElementValidSizes[type]&(1<<sizedesc)) )
			{// Invalid size desc for type.
			LOG2(_L("SDP: Invalid size descriptor %d for type %d!"), sizedesc, type);
			User::Leave(KErrSdpParserInvalidSizeForType);
			}

		TUint elementLen;
		if (type == ETypeNil)
			{// we've already checked that sizedesc == 0
			elementLen = 0;
			}
		else if(sizedesc<=ESizeSixteenBytes)
			{
			elementLen = 1<<sizedesc;
			}
		else
			{
			TUint addSzBytes = 1<<(sizedesc-ESizeOneAdditional);
			if((addSzBytes)>TUint(ptrE-ptr))
				return (ptrE-ptrStart);
			elementLen = SdpUtil::GetUint(TPtrC8(ptr, addSzBytes));
			ptr += addSzBytes;
			}

		if (!iListStack->IsEmpty() && 
			(TInt)((ptr-ptrStart)+elementLen) > iListStack->Head())
			{// Error! This item is longer than the list it is in!!
			User::Leave(KErrSdpParserInvalidSizeForParentList);
			}

		TUint compositeLen = 0;
		if (IsComposite(type))
			{//Composite node. We'll parse down into it.
			compositeLen = elementLen;
			elementLen = 0;		// composites have no element length.
			}

		if((elementLen)>TUint(ptrE-ptr))return (ptrE-ptrStart);

		TPtrC8 data(ptr,elementLen);

		switch (type)
			{
		case ETypeNil:
			iBuilder=iBuilder->BuildNilL();
			break;
		case ETypeUint:
			iBuilder=iBuilder->BuildUintL(data);
			break;
		case ETypeInt:
			iBuilder=iBuilder->BuildIntL(data);
			break;
		case ETypeUUID:
			{
			TUUID uuid;
			uuid.SetL(data);
			iBuilder=iBuilder->BuildUUIDL(uuid);
			}
			break;
		case ETypeString:
			iBuilder=iBuilder->BuildStringL(data);
			break;
		case ETypeBoolean:
			iBuilder=iBuilder->BuildBooleanL(SdpUtil::GetUint(data));
			break;		
		case ETypeURL:
			iBuilder=iBuilder->BuildURLL(data);
			break;
		case ETypeDES:
			iBuilder=iBuilder->BuildDESL();
			break;
		case ETypeDEA:
			iBuilder=iBuilder->BuildDEAL();
			break;
		default:
			iBuilder=iBuilder->BuildUnknownL(type, sizedesc, data);
			break;
			};

		ptr += elementLen;


		if (!iListStack->IsEmpty())
			{// Adjust size of existing head entry so we know when the DES/DEA is finished
			iListStack->Head() -= (ptr-ptrStart)+compositeLen;
			}

		if (IsComposite(type))
			{ // push the length of the DES/DEA on top of the stack and mark the list
			iBuilder=iBuilder->StartListL();
			iListStack->PushL(compositeLen);
			}

		CloseListsL();
		}

	__ASSERT_DEBUG(ptr<=ptrE, ParsePanic(EFrameOverrun));

	return ptrE-ptr;
	}

EXPORT_C TBool CElementParser::BufferedParseL(const TDesC8& aData)
/** Parse out some encoded data, with transparent buffering of unparsed data between 
calls.

The function stores any incompletely parsed data from a previous call, and 
automatically prepends to the data buffer when it is next called.

If the function leaves, the unparsed data will be deleted. This means it will 
not be possible to continue with this data stream; Reset() should be called 
before the next call to this function.

@param aData Buffer to parse
@return True if a whole number of data elements have not been parsed, so more 
data is expected. False if a whole number has been parsed. */
	{
	TPtrC8 data(aData);
	CLinearBuf* remBuf = 0;

	if(iRemainderBuf)
		{//Need to append new bit onto remainder from previous response
		remBuf = iRemainderBuf;
		iRemainderBuf = 0;
		CleanupStack::PushL(remBuf);
		remBuf->AppendL(data);
		data.Set(remBuf->Ptr());
		}

	TInt rem = ParseElementsL(data);

	if(remBuf || rem > 0)
		{
		if(remBuf && rem > 0)
			{// skip the bit just parsed
			remBuf->Consume(remBuf->Size() - rem);
			}
		else if (remBuf) // && rem == 0
			{// no remainder -- remBuf no longer needed
			CleanupStack::PopAndDestroy(); // remBuf
			remBuf = 0;
			}
		else // rem > 0 && remBuf == 0
			{// Store remainder in a new remainder buf
			remBuf = CLinearBuf::NewLC(rem);
			remBuf->AppendL(data.Right(rem));
			}

		if(remBuf)
			{
			CleanupStack::Pop(); // remBuf
			iRemainderBuf = remBuf;
			}
		}
	ASSERT_DEBUG(rem == 0 || rem == ((iRemainderBuf != NULL) ? iRemainderBuf->Size() : 0));
	return iRemainderBuf || !iListStack->IsEmpty();
	}

EXPORT_C void CElementParser::Reset()
/** Resets the parser's buffers to be empty. */
	{
	iListStack->Reset();
	delete iRemainderBuf;
	iRemainderBuf = 0;
	}

EXPORT_C void CElementParser::Reset(MSdpElementBuilder* aBuilder)
/** Resets the parser's buffers to be empty, and resets the element builder object 
used.

@param aBuilder Element builder object to use */
	{
	Reset();
	iBuilder=aBuilder;
	}

void CElementParser::CloseListsL()
	{
	while (!iListStack->IsEmpty() && iListStack->Head() == 0 && iBuilder)
		{// List has ended
		iListStack->Pop();
		iBuilder=iBuilder->EndListL();
		}
	}

EXPORT_C void CElementParser::SetBuilder(MSdpElementBuilder* aBuilder)
	{
	iBuilder = aBuilder;
	}

EXPORT_C MSdpElementBuilder* CElementParser::Builder()
	{
	return iBuilder;
	}
	
// EOF