// Copyright (c) 2008-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
 @internalTechnology
*/

#include <bluetooth/eirdatacodec.h>
#include <utf.h>
#include <bluetooth/logger.h>
#include "eirmanclientlogger.h"

void Panic(TEirCodecPanics aCode)
	{
	User::Panic(KEirCodecPanicName, aCode);
	}

// Offset from Length to EIR Tag in EIR data
const TUint8 KEIRLengthToTagOffset = 1;
// Offset from EIR Tag to EIR data (value) in EIR data
const TUint8 KEIRTagToDataOffset = 1;
// number of bits in eir tag bit mask
const TUint8 KSizeOfEIRTagBitMask = 32;

/**
Extended Inquiry Response Parser Class
This class can take a TNameRecord reference from inquiry result, 
which could hold both local name and Extended Inquiry Response. 
It provides API to parse and return the local name and data for any Extended Inquiry Response tag.
*/

/** 
 Default Constructs an TExtendedInquiryResponseDataCodec object.
@internalTechnology
 */
EXPORT_C TExtendedInquiryResponseDataCodec::TExtendedInquiryResponseDataCodec()
: iEir(NULL, 0, 0), iOffset(0)
	{
	LOG_FUNC
	}

/** 
 Constructs an TExtendedInquiryResponseDataCodec object from an TNameRecord.

 TNameRecord.iName will be copied into a 8-bit descriptor and stored in the object.

 @param aDes Data buffer for extended inquiry response 
 @internalTechnology
*/
EXPORT_C TExtendedInquiryResponseDataCodec::TExtendedInquiryResponseDataCodec(const TNameRecord& aNameRecord)
: iEir(NULL, 0, 0), iOffset(0)
	{
	LOG_FUNC
	// We won't check if the descriptor is the standard EIR size, as it can be reformed to have a whole name.
	Set(aNameRecord);
	}

/** 
 Constructs an TExtendedInquiryResponseDataCodec object from an TNameRecord.

 TNameRecord.iName will be copied into a 8-bit descriptor and stored in the object.

 @param aDes Data buffer for extended inquiry response 
 @internalTechnology
*/
EXPORT_C TExtendedInquiryResponseDataCodec::TExtendedInquiryResponseDataCodec(TNameRecord& aNameRecord)
: iEir(NULL, 0, 0), iOffset(0)
	{
	LOG_FUNC
	// We won't check if the descriptor is the standard EIR size, as it can be reformed to have a whole name.
	Set(aNameRecord);
	}

/** 
 Constructs an TExtendedInquiryResponseDataCodec object from an 8-bit data buffer.

 A copy of the buffer is stored in the object.

 @param aDes Data buffer for extended inquiry response 
 @internalTechnology
*/
EXPORT_C TExtendedInquiryResponseDataCodec::TExtendedInquiryResponseDataCodec(const TDesC8& aDes)
:  iEir(NULL, 0, 0), iOffset(0)
	{
	LOG_FUNC
	Set(aDes);
	}
/** 
 Constructs an TExtendedInquiryResponseDataCodec object from an 8-bit data buffer.

 A copy of the buffer is stored in the object.

 @param aDes Data buffer for extended inquiry response 
 @internalTechnology
*/
EXPORT_C TExtendedInquiryResponseDataCodec::TExtendedInquiryResponseDataCodec(TDes8& aDes)
:  iEir(NULL, 0, 0), iOffset(0)
	{
	LOG_FUNC
	Set(aDes);
	}

/**
 Retrieve the EIR data for a particular Data Type 
 @param aDataType Data Type to look for
 @param aDes Pointer descriptor that will point to the EIR data for the Data Type requested if successful 
 (please note this does not contain the Data Type byte) 
 @return an error code
 @internalTechnology
 */
EXPORT_C TInt TExtendedInquiryResponseDataCodec::GetData(TExtendedInquiryResponseDataType aDataType, TPtrC8& aDes) const
	{
	LOG_FUNC
	TInt offset = NextDataType(0);

	while(offset >= KErrNone)
		{
		if(iEir[offset] == aDataType)
			{
			aDes.Set(iEir.Mid(offset + KEIRTagToDataOffset, iEir[offset - KEIRLengthToTagOffset] - KEIRLengthToTagOffset));
			return KErrNone;
			}
		else
			{
			offset = NextDataType(offset);
			}
		}

	return offset;
	}
/**
 Retrieve the EIR data for the next Data Type 
 @param aOffset Offset to current data type (0 to start traversing)
 @param aDes Pointer descriptor that will point to the EIR data for the Data Type requested if successful 
 (please note this does not contain the Data Type byte) 
 @return TExtendedInquiryResponseDataType (TExtendedInquiryResponseDataType::EEirInvalid means there is no more eir data to get)
 @internalTechnology
 */
EXPORT_C TExtendedInquiryResponseDataType TExtendedInquiryResponseDataCodec::GetNextData(TPtrC8& aDes)
	{
	LOG_FUNC
	TExtendedInquiryResponseDataType dataType;
	iOffset = NextDataType(iOffset);

	if(iOffset >= KErrNone && iEir.Length() >= (iOffset +iEir[iOffset - KEIRLengthToTagOffset]))
		{
		aDes.Set(iEir.Mid(iOffset + KEIRTagToDataOffset, iEir[iOffset-KEIRLengthToTagOffset] - KEIRLengthToTagOffset));
		dataType = static_cast<TExtendedInquiryResponseDataType>(iEir[iOffset]);
		}
	else
		{
		// Data must be malformed or corrupted
		dataType = EEirInvalid;
		}

	return dataType;
	}
	
/**
 Find out whether a particular Data Type is present in this TExtendedInquiryResponseDataCodec
 @param aDataType Data Type to look for
 @return ETrue if Data Type present, EFalse otherwise
 @internalTechnology
 */
EXPORT_C TBool TExtendedInquiryResponseDataCodec::IsDataTypePresent(TExtendedInquiryResponseDataType aDataType) const
	{
	LOG_FUNC
	TInt offset = NextDataType(0);
	TBool found = EFalse;

	while(offset >= KErrNone)
		{
		if(iEir[offset] == aDataType)
			{
			found = ETrue;
			break;
			}

		offset = NextDataType(offset);
		}

	return found;
	}

/**
 Obtain the Device Name from inquiry response. This may be a complete or partial name depending on what is available.
 @param aName is the Device Name converted into Unicode format
 @return TEIRDataCompleteness (Partial or Complete) or an error code
 @internalTechnology
 */
EXPORT_C TInt TExtendedInquiryResponseDataCodec::GetDeviceName(TPtrC8& aName) const
	{
	LOG_FUNC
	TInt completeness = EDataComplete;
	TInt error = GetData(EEirLocalNameComplete, aName);
	if(error != KErrNone)
		{
		error = GetData(EEirLocalNamePartial, aName);
		completeness = EDataPartial;
		}

	return error == KErrNone ? completeness : error;
	}

/**
 Set the Device Name in the EIR buffer from a TPtrC8. This may be a complete or partial name.
 @param aName is the Device Name converted into Unicode format
 @param aIsComplete is marking if the name is complete or partial
 @return TInt an error code
 @internalTechnology
 */
EXPORT_C TInt TExtendedInquiryResponseDataCodec::SetDeviceName(const TPtrC8& aName, TBool aIsComplete)
	{
	TPtrC8 name;
	TInt error = KErrNotFound;
	TInt offset = NextDataType(0);
	TInt nameTag = (aIsComplete ? EEirLocalNameComplete : EEirLocalNamePartial);
	TBool replaceCurrentName = ETrue;

	while(offset >= KErrNone)
		{
		if(iEir[offset] == EEirLocalNameComplete || iEir[offset] == EEirLocalNamePartial)
			{
			name.Set(iEir.Mid(offset + KEIRTagToDataOffset, iEir[offset-KEIRLengthToTagOffset] - KEIRLengthToTagOffset));
			if(iEir[offset] == EEirLocalNameComplete && name.Compare(aName) == 0)
				{
				// The only scenario we don't want to replace the existing name is when
				// it's complete and same as the new one (aName)
				replaceCurrentName = EFalse;
				LOG(_L("We won't replace the current name"));
				}
			error = KErrNone;
			break;
			}
		else
			{
			offset = NextDataType(offset);
			}
		}

	if(error == KErrNotFound)
		// no device name present, we will add the name to the end of the eir data
		{
		if(iEir.MaxLength() < (iEir.Length() + KEIRTagToDataOffset + KEIRLengthToTagOffset + aName.Length()))
			{
			// Not enough space to store this name and its length & tag
			return KErrNoMemory;
			}
		// Add length
		iEir.Append(aName.Length() + KEIRTagToDataOffset);
		// Append Tag
		iEir.Append(nameTag);
		// Append value
		iEir.Append(aName);
		LOG1(_L("EIR data with name appended: %d bytes of data"), iEir.Size());
		LOGHEXDESC(iEir);
		error = KErrNone;
		}
	else if(replaceCurrentName)
		// device name exists in current eir and it's either partial or different from aName, we'll update it with aName
		{
		// move all the data on the right of device name to the left and then append new name after it
		TPtr8 rightPtr = iEir.RightTPtr(iEir.Length() - offset - name.Length() - KEIRLengthToTagOffset);
		iEir.Replace(offset-KEIRLengthToTagOffset, iEir.Length() - offset + KEIRLengthToTagOffset, rightPtr);
		iEir.SetLength(offset + rightPtr.Length() - KEIRTagToDataOffset);
		// Check if the new name is too big for iEir
		if(iEir.MaxLength() < (iEir.Length() + KEIRTagToDataOffset + KEIRLengthToTagOffset + aName.Length()))
			{
			// Not enough space to store this name and its length & tag
			return KErrNoMemory;
			}
		// Add length
		iEir.Append(aName.Length() + KEIRTagToDataOffset);
		// Append Tag
		iEir.Append(nameTag);
		// Append value
		iEir.Append(aName);
		LOG(_L("Reshuffled EIR data:"));
		LOGHEXDESC(iEir);
		error = KErrNone;
		}
	// otherwise we do nothing, as this is the case of an identical complete name is already present.
	if(iNameRecord)
		{
		if(iEir.Length() > 0)
			{
			iNameRecord->iName.SetLength(((iEir.Length() + iEir.Length()%2)/2));
			}
		else
			{
			iNameRecord->iName.SetLength(0);
			}
		}
	return error;
	}

/**
 Private Setter, used by the constructor and the assignment operator
 @param aNameRecord TNameRecord to create extended inquiry response from
 */
EXPORT_C void TExtendedInquiryResponseDataCodec::Set(const TNameRecord& aNameRecord)
	{
	LOG_FUNC
	Set(const_cast<TNameRecord&>(aNameRecord));
	}

/**
 Private Setter, used by the constructor and the assignment operator
 @param aNameRecord TNameRecord to create extended inquiry response from
 */
EXPORT_C void TExtendedInquiryResponseDataCodec::Set(TNameRecord& aNameRecord)
	{
	LOG_FUNC
	TUint8* name = (TUint8*)(aNameRecord.iName.Ptr());
	TPtr8 namePtr(name, aNameRecord.iName.Size(), aNameRecord.iName.MaxSize());
	iNameRecord = &aNameRecord; 
	Set(namePtr);
	}

/**
 Private Setter, used by the constructor and the assignment operator
 @param aDes Data buffer to create extended inquiry response from
 */
EXPORT_C void TExtendedInquiryResponseDataCodec::Set(const TDesC8& aDes)
	{
	LOG_FUNC
	TPtr8 ptr(const_cast<TUint8*>(aDes.Ptr()), aDes.Length(), aDes.Length());
	Set(ptr);
	}
/**
 Private Setter, used by the constructor and the assignment operator
 @param aDes Data buffer to create extended inquiry response from
 */
EXPORT_C void TExtendedInquiryResponseDataCodec::Set(TDes8& aDes)
	{
	LOG_FUNC
	// Check length consistency
	TUint16 length = ComputeSignificantLength(aDes);
	if(length > KNameRecord8BitMaxLength)
		{
		// Reset the EIR and discard any data it may contain, since it was malformed anyway
		iEir.Set(NULL, 0, 0);
		}
	else
		{
		iEir.Set(const_cast<TUint8*>(aDes.Ptr()), length, aDes.MaxLength());
		}
	}

EXPORT_C void TExtendedInquiryResponseDataCodec::Copy(TDesC8& aDes)
	{
	__ASSERT_DEBUG(iEir.MaxLength() >= aDes.Length(), Panic(EEirCodecDataTooLarge));
	TUint16 length = ComputeSignificantLength(aDes);
	iEir.Copy(aDes);
	iEir.SetLength(length);
	iNameRecord->iName.SetLength((iEir.Length()/2)+1);
	}

EXPORT_C TInt TExtendedInquiryResponseDataCodec::DoSanityCheck(TDes8& aDes)
	{
	TInt error = KErrNone;
	TInt offset = NextDataType(0);
	TUint32 eirTagPresentFlag = 0;	// this is a bit mask for existing eir types
	TInt tag = 0;

	while(offset >= KErrNone)
		{
		if(!IsValideDataType(iEir[offset]))
			{
			// the next data type isn't a known(valid) eir tag
			error = KErrNotSupported;
			break;
			}
		if(static_cast<TInt>(iEir[offset - KEIRLengthToTagOffset]) < 0)
			{
			// length is less than 0
			error = KErrUnderflow;
			break;
			}
		tag = (iEir[offset] == EEirVendorSpecific ? KSizeOfEIRTagBitMask : iEir[offset]);
		// check if the tag is already present from previous parsing
		if(eirTagPresentFlag & (1 << tag))
			{
			error = KErrAlreadyExists;
			break;
			}
		else
			{
			// set flag for this data tag
			eirTagPresentFlag |= (1 << tag);
			offset = NextDataType(offset);
			}
		}
	error = offset == KErrCorrupt ? offset : error;
	if(error != KErrNone)
		{
		// remove all the data after this LTV unit
		iEir.SetLength(offset - KEIRLengthToTagOffset);
		aDes.SetLength(offset - KEIRLengthToTagOffset);
		}
	return error;
	}

/**
 Computes the length of Significant part in an Extended Inquiry Response data.

 @param aDes Extended Inquiry Response data
 */
TUint16 TExtendedInquiryResponseDataCodec::ComputeSignificantLength(const TDesC8 &aDes)
	{
	LOG_FUNC
	TUint desLen = aDes.Length();
	const TUint8 *ptr = aDes.Ptr();
	TUint16 i = 0;
	while(i < desLen && ptr[i] != 0x00)
		{
		i += ptr[i] + KEIRLengthToTagOffset;
		}
	return i;
	}

/**
 @param aOffset Offset to current data type (0 to start traversing)
 @return an error code or Offset to the next EIR data type
 */
TInt TExtendedInquiryResponseDataCodec::NextDataType(TInt aOffset) const
	{
	LOG_FUNC
	// Check bounds
	TInt length = iEir.Length();
	TInt ret = KErrNotFound;
	
	// Check the values of aOffset and length are correct, and aOffset is not bigger than the length
	if(aOffset > 0 && aOffset <= length)
		{
		// Get the Offset for next data type, aDes[aOffset-1] holds the length for each EIR structure
		TInt newOffset = iEir[aOffset - KEIRLengthToTagOffset] + aOffset + KEIRLengthToTagOffset;
		if(newOffset > length)
			{
			if(newOffset != length + KEIRLengthToTagOffset)
				{
				ret = KErrCorrupt;
				}
			}
		else
			{
			ret = newOffset;
			}
		}
	
	// Offset for the first data type
	else if(aOffset == 0 && length > 0)
		{
		ret = KEIRLengthToTagOffset;
		}
	return ret;
	}

TBool TExtendedInquiryResponseDataCodec::IsValideDataType(TInt aDataType)
	{
	TBool ret = EFalse;
	if((aDataType >= EEirFlags && aDataType <= EEirOobSimplePairingRandomizerR) || aDataType == EEirVendorSpecific)
		{
		ret = ETrue;
		}
	return ret;
	}