// Copyright (c) 1999-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:

// This file implements the different PDU elements

// 

//

/**

 @file

*/

#include <gsmuelem.h>

#include <gsmumsg.h>

#include "Gsmumain.h"

#include <gsmusar.h>

#include "gsmupriv.h"

#include <s32strm.h>

#include <etelmm.h>

#include <gsmuetel.h>

#include <exterror.h>

#include <emsinformationelement.h>

#include <emsformatie.h>

#include <charconv.h>

/**

 *  Question Mark character.

 */

const TInt  KReplacementCharacter = 0x003f;

/**

 *  Constructs the object with a descriptor. The extraction mark and next character members are initialised to point to the start of the string.

 *  

 *  @param aSource Descriptor to be assigned by reference

 */

TGsmuLex8::TGsmuLex8(const TDesC8& aSource): TLex8(aSource)

	{

	//NOP

	} // TGsmuLex8::TGsmuLex8

/**

 *  Gets the next character in the string and increments the next character position.

 *  

 *  @return The next character in the string

 *  @leave Leaves with KErrGsmuDecoding if at end of string

 */

TUint8 TGsmuLex8::GetL()

	{

	if (Eos())

		LeaveL();

	return static_cast<TUint8>(Get());

	} // TGsmuLex8::GetL

/**

 *  Increments the next character position by aNumber

 *  

 *  @param aNumber The number of characters to increment the next character position by.

 *  @leave If the increment puts the next character position before the start or beyond the end of the string, the function leaves with KErrGsmuDecoding.

 */

void TGsmuLex8::IncL(TInt aNumber)

	{

	if (aNumber != 0)

		{

		if (aNumber < 0 || Eos() || Remainder().Length() < aNumber)

			LeaveL();

		else

			Inc(aNumber);

		}

	} // TGsmuLex8::IncL

/**

 *  Checks there are enough remaining characters, then returns a TPtrC containing the next aLength characters. Does not increment the current position.

 *  

 *  @param aLength Number of characters to return

 *  @return Remainder().Left(aLength)

 *  @leave Leaves with KErrGsmuDecoding if there are insufficient characters remaining

 */

TPtrC8 TGsmuLex8::NextWithNoIncL(TInt aLength) const

	{

	return NextWithNoIncL(aLength, EFalse);

	}

/**

 * Checks there are enough remaining characters, then returns a TPtrC containing the next aLength characters. Does not increment the current position.

 *

 * @param aLength Number of characters to return

 * @param aAcceptTruncation ETrue if a mismatch between length indicator and actual length is acceptable. EFalse otherwise.

 * @return Remainder().Left(aLength) if aAcceptTruncation is EFalse. Remainder() otherwise.

 * @leave Leaves with KErrGsmuDecoding if there are insufficient characters remaining, unless aAcceptTruncation is ETrue.

 */

TPtrC8 TGsmuLex8::NextWithNoIncL(TInt aLength, TBool aAcceptTruncation) const

	{

	const TPtrC8 remainder(Remainder());

	if ( (aLength < 0) || (remainder.Length()< aLength && !aAcceptTruncation) )

		{

		LeaveL();

		}

  if (!aAcceptTruncation)

		{

		return Remainder().Left(aLength);

		}

	// aAcceptTruncation is ETrue

	else if (remainder.Length() < aLength)

		{

		return Remainder();

		}

	// otherwise, no need for truncation:

	return Remainder().Left(aLength);

	}

/**

 *  Calls TGsmuLeax8::NextWithNoIncL then increments the next character position by aLength

 *  

 *  @param aLength Number of characters to return and increment the next character position

 *  @return Remainder().Left(aLength)

 *  @leave If the increment puts the next character position before the start or beyond the end of the string, the function leaves with KErrGsmuDecoding.

 */

TPtrC8 TGsmuLex8::NextAndIncL(TInt aLength)

	{

	const TPtrC8 next(NextWithNoIncL(aLength));

	IncL(aLength);

	return next;

	} // TGsmuLeax8::NextWithNoIncL

const TSmsOctet& TSmsOctet::operator = (TInt aValue)

	{

	iValue = static_cast<TUint8>(aValue);

	return *this;

	} // TSmsOctet::operator

TUint8* TSmsOctet::EncodeL(TUint8* aPtr) const

	{

	*aPtr=iValue;

	return aPtr+1;

	} // TSmsOctet::EncodeL

TSmsFirstOctet::TSmsFirstOctet(TInt aValue):

	TSmsOctet(aValue)

	{

	} // TSmsFirstOctet::TSmsFirstOctet

const TSmsFirstOctet& TSmsFirstOctet::operator = (TInt aValue)

	{

	TSmsOctet::operator = (aValue);

	return *this;

	} // TSmsFirstOctet::operator

TSmsFailureCause::TSmsFailureCause():

	TSmsOctet(ESmsErrorUnspecified)

	{

	} // TSmsFailureCause::TSmsFailureCause

TSmsStatus::TSmsStatus():

	TSmsOctet(ESmsShortMessageReceivedBySME)

	{

	} // TSmsStatus::TSmsStatus

CSmsCommandData* CSmsCommandData::NewL(TSmsFirstOctet& aFirstOctet)

	{

	LOGGSMU1("CSmsCommandData::NewL()");

	CSmsCommandData* commanddata=new(ELeave) CSmsCommandData(aFirstOctet);

	CleanupStack::PushL(commanddata);

	TPtrC8 ptr;

	commanddata->SetDataL(ptr);

	CleanupStack::Pop();

	return commanddata;

	} // CSmsCommandData::NewL

CSmsCommandData::~CSmsCommandData()

	{

	iInformationElementArray.ResetAndDestroy();

	delete iBuffer;

	} // CSmsCommandData::NewL

/**

 *  Duplicates this CSmsCommandData object.

 * 

 *  @return  Pointer to the newly created CSmsCommandData object.

 */

CSmsCommandData* CSmsCommandData::DuplicateL() const

	{

	LOGGSMU1("CSmsCommandData::DuplicateL()");

	CSmsCommandData*  smsCommandData = CSmsCommandData::NewL(iFirstOctet);

	CleanupStack::PushL(smsCommandData);

	smsCommandData->SetDataL(Data());

	for (TInt ie = 0;  ie < iInformationElementArray.Count();  ie++)

		{

		smsCommandData->AddInformationElementL(iInformationElementArray[ie]->Identifier(),

											   iInformationElementArray[ie]->Data());

		}

	CleanupStack::Pop(smsCommandData);

	return smsCommandData;

	} // CSmsCommandData::DuplicateL

CSmsInformationElement& CSmsCommandData::InformationElement(TInt aIndex) const

	{

	LOGGSMU1("CSmsCommandData::InformationElement()");

	CSmsInformationElement* ie=iInformationElementArray[aIndex];

	return *ie;

	} // CSmsCommandData::InformationElement

CSmsInformationElement*& CSmsCommandData::InformationElementPtr(TInt aIndex)

    {

    // Ignore in code coverage - not used in SMS stack and not exported

    // but cannot be removed as impacts public header.

    BULLSEYE_OFF    

    LOGGSMU1("CSmsCommandData::InformationElementPtr()");

    return iInformationElementArray[aIndex];

    BULLSEYE_RESTORE

    }

TBool CSmsCommandData::InformationElementIndex(CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier,

		TInt& aIndex) const

	{

	LOGGSMU1("CSmsCommandData::InformationElementIndex()");

	TBool found=EFalse;

	TInt count=NumInformationElements();

	for (TInt i=0; (!found) && (i<count); i++)

		if (InformationElement(i).Identifier()==aIdentifier)

			{

			found=ETrue;

			aIndex=i;

			}

	return found;

	} // CSmsCommandData::InformationElementIndex

void CSmsCommandData::AddInformationElementL(const TSmsId aIdentifier,const TDesC8& aData)

	{

	LOGGSMU1("CSmsCommandData::AddInformationElementL()");

	//

	// Currently there is no restriction on how many instances of an information element can be

	// placed in the collection.

	// No restriction will be placed on the number of Special SMS Message Indications that can be

	// added in order to maintain FC.

	// (cf CSmsUserData::AddInformationElementL(const TSmsId aIdentifier,const TDesC8& aData);

	//

	CSmsInformationElement* informationelement=CSmsInformationElement::NewL(aIdentifier,aData);

	CleanupStack::PushL(informationelement);

	iInformationElementArray.AppendL(informationelement);

	CleanupStack::Pop();

	if (NumInformationElements()>=1)

		SetHeaderPresent(ETrue);

	} // CSmsCommandData::AddInformationElementL

void CSmsCommandData::RemoveInformationElement(TInt aIndex)

	{

	LOGGSMU1("CSmsCommandData::RemoveInformationElement()");

	// Since iInformationElementArray[aIndex] is removed from iInformationElementArray, no double free issue.

	// coverity[double_free]

	delete iInformationElementArray[aIndex];

	iInformationElementArray[aIndex] = NULL;

	iInformationElementArray.Delete(aIndex);

	if (NumInformationElements()==0)

		{

		SetHeaderPresent(EFalse);

		}

	} // CSmsCommandData::RemoveInformationElement

TPtrC8 CSmsCommandData::Data() const

	{

	LOGGSMU1("CSmsCommandData::Data()");

	TPtrC8 ptr;

	ptr.Set(iBuffer->Des());

	return ptr;

	} // CSmsCommandData::Data

void CSmsCommandData::SetDataL(const TDesC8& aData)

	{

	LOGGSMU1("CSmsCommandData::SetDataL()");

	TInt length=aData.Length();

	__ASSERT_DEBUG(length<=KSmsMaxDataSize,Panic(KGsmuPanicCommandDataLengthTooLong));

	HBufC8* buffer=HBufC8::NewL(length);

	delete iBuffer;

	iBuffer=buffer;

	iBuffer->Des().SetLength(length);

	iBuffer->Des().Copy(aData);

	} // CSmsCommandData::SetDataL

TUint8* CSmsCommandData::EncodeL(TUint8* aPtr) const

	{

	LOGGSMU1("CSmsCommandData::EncodeL()");

	__ASSERT_DEBUG(iBuffer->Length()<=MaxDataLength(),Panic(KGsmuPanicCommandDataBufferTooLong));

	TSmsOctet datalength=iBuffer->Length()+TSmsOctet(TotalHeaderLengthInUDLUnits());

	aPtr=datalength.EncodeL(aPtr);

	TPtr8 ptr((TUint8*) aPtr,datalength);

    if (HeaderPresent())

        {

		TSmsOctet headerLength(HeaderLength());

		aPtr=headerLength.EncodeL(aPtr);

		for (TInt i=0; i<NumInformationElements(); i++)

		    {

			aPtr=iInformationElementArray[i]->EncodeL(aPtr);

		    }

        }

	ptr.Copy(iBuffer->Des());

	aPtr+=TInt(iBuffer->Length());

	return aPtr;

	} // CSmsCommandData::EncodeL

void CSmsCommandData::DecodeL(TGsmuLex8& aPdu)

	{

	LOGGSMU1("CSmsCommandData::DecodeL()");

	iInformationElementArray.ResetAndDestroy();

	const TBool headerPresent=HeaderPresent();

	TSmsOctet dataLength;

	dataLength.DecodeL(aPdu);

	if (headerPresent)

		{

		TSmsOctet headerLength;

		headerLength.DecodeL(aPdu);

		if ((1+headerLength)>KSmsMaxDataSize)

			User::Leave(KErrGsmSMSTpduNotSupported);

		while (HeaderLength()<headerLength)

			{

			CSmsInformationElement* informationElement=CSmsInformationElement::NewL();

			CleanupStack::PushL(informationElement);

			informationElement->DecodeL(aPdu);

			iInformationElementArray.AppendL(informationElement);

			CleanupStack::Pop(informationElement);

			}

		if (HeaderLength()!=headerLength)

			User::Leave(KErrGsmSMSTpduNotSupported);

		}

	const TInt totalHeaderLength=TotalHeaderLengthInUDLUnits();

	const TInt totalDataLength=dataLength-totalHeaderLength;

	const TPtrC8 next(aPdu.NextAndIncL(totalDataLength));

	SetDataL(next);

	} // CSmsCommandData::DecodeL

void CSmsCommandData::InternalizeL(RReadStream& aStream)

	{

	iInformationElementArray.ResetAndDestroy();

	TInt numInformationElements=aStream.ReadInt32L();

	for (TInt i=0; i<numInformationElements; i++)

		{

		CSmsInformationElement* informationElement=CSmsInformationElement::NewL();

		CleanupStack::PushL(informationElement);

		aStream >> *informationElement;

		iInformationElementArray.AppendL(informationElement);

		CleanupStack::Pop();

		}

	HBufC8* buffer=HBufC8::NewL(aStream,KSmsMaxDataSize);

	delete iBuffer;

	iBuffer=buffer;

	} // CSmsCommandData::InternalizeL

void CSmsCommandData::ExternalizeL(RWriteStream& aStream) const

	{

	TInt numInformationElements=iInformationElementArray.Count();

	aStream.WriteInt32L(numInformationElements);

	for (TInt i=0; i<numInformationElements; i++)

		aStream << *iInformationElementArray[i];

	aStream << *iBuffer;

	} // CSmsCommandData::ExternalizeL

CSmsCommandData::CSmsCommandData(TSmsFirstOctet& aFirstOctet):

	iFirstOctet(aFirstOctet),

	iInformationElementArray(8)

	{

	} // CSmsCommandData::CSmsCommandData

TInt CSmsCommandData::HeaderLength() const

	{

	LOGGSMU1("CSmsCommandData::HeaderLength()");

	TInt headerLength=0;

	for (TInt i=0; i<NumInformationElements(); i++)

		headerLength+=iInformationElementArray[i]->Length();

	return headerLength;

	} // CSmsCommandData::HeaderLength

TInt CSmsCommandData::TotalHeaderLengthInUDLUnits() const

	{

	LOGGSMU1("CSmsCommandData::TotalHeaderLengthInUDLUnits()");

	if (iInformationElementArray.Count()==0)

		return 0;

	else

		return (HeaderLength()+1);   // +1 stands for  UDHL

	} // CSmsCommandData::TotalHeaderLengthInUDLUnits

TBool CSmsCommandData::HeaderPresent() const

	{

	LOGGSMU1("CSmsCommandData::HeaderPresent()");

	return (iFirstOctet&TSmsFirstOctet::ESmsUDHIMask)==TSmsFirstOctet::ESmsUDHIHeaderPresent;

	} // CSmsCommandData::HeaderPresent

void CSmsCommandData::SetHeaderPresent(TBool aHeaderPresent)

	{

	LOGGSMU1("CSmsCommandData::SetHeaderPresent()");

	iFirstOctet=aHeaderPresent? (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderPresent: (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderNotPresent;

	} // CSmsCommandData::SetHeaderPresent

TSmsParameterIndicator::TSmsParameterIndicator():

	TSmsOctet(ESmsPIDProtocolIdentifierPresent|ESmsPIDUserDataPresent|ESmsPIDDataCodingSchemePresent)

	{

	} // TSmsParameterIndicator::TSmsParameterIndicator

TSmsCommandType::TSmsCommandType():

	TSmsOctet(ESmsCommandTypeEnquiry)

	{

	} // TSmsCommandType::TSmsCommandType

TSmsProtocolIdentifier::TSmsProtocolIdentifier():

	TSmsOctet((TInt)ESmsPIDTelematicInterworking|(TInt)ESmsNoTelematicDevice)

	{

	} // TSmsProtocolIdentifier::TSmsProtocolIdentifier

TSmsProtocolIdentifier::TSmsTelematicDeviceIndicator TSmsProtocolIdentifier::TelematicDeviceIndicator() const

	{

	__ASSERT_DEBUG(PIDType()==ESmsPIDTelematicInterworking,Panic(KGsmuPanicNoTelematicInterworking));

	return (TSmsTelematicDeviceIndicator) (iValue&EPIDTelematicDeviceIndicatorMask);

	} // TSmsProtocolIdentifier::TSmsTelematicDeviceIndicator

void TSmsProtocolIdentifier::SetTelematicDeviceIndicator(TSmsTelematicDeviceIndicator aIndicator)

	{

	LOGGSMU1("TSmsProtocolIdentifier::SetTelematicDeviceIndicator()");

	__ASSERT_DEBUG(PIDType()==ESmsPIDTelematicInterworking,Panic(KGsmuPanicNoTelematicInterworking));

	//iValue=(TUint8) ((iValue&ESmsPIDTypeMask)|aIndicator);

	iValue=(TUint8) ((iValue&(~EPIDTelematicDeviceIndicatorMask))|aIndicator);

	} // TSmsProtocolIdentifier::SetTelematicDeviceIndicator

TSmsProtocolIdentifier::TSmsTelematicDeviceType TSmsProtocolIdentifier::TelematicDeviceType() const

	{

	__ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));

	return (TSmsTelematicDeviceType) (iValue&ESmsTelematicDeviceTypeMask);

	} // TSmsProtocolIdentifier::TSmsTelematicDeviceType

void TSmsProtocolIdentifier::SetTelematicDeviceType(TSmsTelematicDeviceType aDeviceType)

	{

	LOGGSMU1("TSmsProtocolIdentifier::SetTelematicDeviceType()");

	__ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));

	iValue=(TUint8) ((iValue&(~ESmsTelematicDeviceTypeMask))|aDeviceType);

	} // TSmsProtocolIdentifier::SetTelematicDeviceType

TInt TSmsProtocolIdentifier::ShortMessageALProtocol() const

    {

    // Ignore in code coverage - not used in SMS stack and not exported

    // but cannot be removed as impacts public header.

    BULLSEYE_OFF    

    LOGGSMU1("TSmsProtocolIdentifier::ShortMessageALProtocol()");

    __ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsNoTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));

    return (TSmsShortMessageALProtocol) (iValue&ESmsShortMessageALProtocolMask);

    BULLSEYE_RESTORE

    }

void TSmsProtocolIdentifier::SetShortMessageALProtocol(TSmsShortMessageALProtocol aProtocol)

    {

    // Ignore in code coverage - not used in SMS stack and not exported

    // but cannot be removed as impacts public header.

    BULLSEYE_OFF    

    LOGGSMU1("TSmsProtocolIdentifier::SetShortMessageALProtocol()");

    __ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsNoTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));