// 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:
// Contains the implementation of the CSmsMessage class
// 
//

/**
 @file
*/

#include <gsmumsg.h>
#include "Gsmumain.h"
#include <gsmubuf.h>
#include <gsmuset.h>
#include <gsmusar.h>
#include "gsmumsgadditionalattributes.h"
#include <gsmuieoperations.h>
#include <gsmunonieoperations.h>

#include <logwrap.h> //  Used for KLogNullId only
#include <e32uid.h>
#include <etelmm.h>
#include <logwraplimits.h>

#include <emsinformationelement.h>
#include <emsformatie.h>
#include <emsuserpromptie.h>
#include <emsobjectdistributionie.h>
#include "smsstackutils.h"

/**
 *  Allocates and creates a CSmsMessage instance from a TGsmSms.
 *  
 *  The type of SMS-XXXX message to construct is defined by the first byte of
 *  the TGsmSms TPDU header.
 *  
 *  @param aFs Reference handle to the file system
 *  @param aGsmSms Reference to TGsmSms
 *  @param aBuffer The Unicode text for the message. The object takes ownership
 *  of aBuffer.
 *  @param aIsRPError Set to true if the message contains Reply Path Error. Default
 *  is false.
 *  @param aIsMobileTerminated Set to True if the message is Mobile Terminated.
 *  Default is false.
 *  @return New CSmsMessage object
 *  @capability None
 */
EXPORT_C CSmsMessage* CSmsMessage::NewL(RFs& aFs, const TGsmSms& aGsmSms,CSmsBufferBase* aBuffer, TBool aIsRPError,TBool aIsMobileTerminated)
	{
	LOGGSMU1("CSmsMessage::NewL()");
	
	CleanupStack::PushL(aBuffer);
	CSmsMessage* smsmessage=new(ELeave) CSmsMessage(aFs, aBuffer);
	CleanupStack::Pop();
	CleanupStack::PushL(smsmessage);
	smsmessage->ConstructL(aGsmSms, aIsRPError,aIsMobileTerminated);
	CleanupStack::Pop();
	return smsmessage;
	} // CSmsMessage::NewL


/**
 *  Allocates and creates a CSmsMessage, specifying the SMS-XXX message type with
 *  a CSmsPDU::TSmsPduType.
 *  
 *  @param aFs Reference handle to the file system
 *  @param aType The PDU type
 *  @param aBuffer The Unicode text for the message. The object takes ownership
 *  of aBuffer.
 *  @param aIsRPError Set to true if the message contains Reply Path Error. Default
 *  is false.
 *  @return New CSmsMessage object
 *  @capability None
 */
EXPORT_C CSmsMessage* CSmsMessage::NewL(RFs& aFs, CSmsPDU::TSmsPDUType aType,CSmsBufferBase* aBuffer,TBool aIsRPError)
	{
	LOGGSMU1("CSmsMessage::NewL()");

	CleanupStack::PushL(aBuffer);
	CSmsMessage* smsmessage=new(ELeave) CSmsMessage(aFs, aBuffer);
	CleanupStack::Pop();
	CleanupStack::PushL(smsmessage);
	smsmessage->ConstructL(aType,aIsRPError);
	CleanupStack::Pop();
	return smsmessage;
	} // CSmsMessage::NewL


/**
 *  Destructor, frees resources.
 *  @capability None
 */
EXPORT_C CSmsMessage::~CSmsMessage()
	{
	LOGGSMU1("CSmsMessage::~CSmsMessage()");

	delete iSmsPDU;
	delete iBuffer;
	delete iCharacterSetConverter;

	if (iInformationElementArray)
		{
		iInformationElementArray->ResetAndDestroy();
		delete iInformationElementArray;
		}

	delete iAdditionalInfo;
	} // CSmsMessage::NewL


/**
 *  Internalises all object data except for the CSmsBufferBase.
 *  
 *  This is used when the buffer is stored elsewhere.
 *  
 *  @param aStream Stream to read from
 *  @capability None
 */
EXPORT_C void CSmsMessage::InternalizeWithoutBufferL(RReadStream& aStream)
	{
	LOGGSMU1("CSmsMessage::InternalizeWithoutBufferL()");

	InternalizeWithoutBufferAndVersionL(aStream);
	InternalizeVersionL(aStream);

	iAdditionalInfo->ResetAttributesL();

	if (iVersion > ESmsMessageV0)
        {
        iAdditionalInfo->InternalizeL(aStream, iVersion);
		}
	} // CSmsMessage::InternalizeWithoutBufferL


/**
 *  Externalises all object data except for the CSmsBufferBase.
 *  
 *  This is used when the buffer is stored elsewhere.
 *  
 *  @param aStream Stream to write to
 *  @capability None
 */
EXPORT_C void CSmsMessage::ExternalizeWithoutBufferL(RWriteStream& aStream) const
	{
	LOGGSMU1("CSmsMessage::ExternalizeWithoutBufferL()");

	ExternalizeWithoutBufferAndVersionL(aStream);
	ExternalizeVersionL(aStream);

	if (iVersion > ESmsMessageV0)
		{
		iAdditionalInfo->ExternalizeL(aStream, iVersion);
		}
	} // CSmsMessage::ExternalizeWithoutBufferL


/**
 *  Internalises all object data.
 *  
 *  @param aStream Stream to read from
 *  @capability None
 */
EXPORT_C void CSmsMessage::InternalizeL(RReadStream& aStream)
	{
	LOGGSMU1("CSmsMessage::InternalizeL()");

	InternalizeWithoutBufferAndVersionL(aStream);
	InternalizeBufferL(aStream);
	InternalizeVersionL(aStream);

	iAdditionalInfo->ResetAttributesL();
	if (iVersion > ESmsMessageV0)
		{
		iAdditionalInfo->InternalizeL(aStream, iVersion);
		}
	} // CSmsMessage::InternalizeL


/**
 *  Externalises all object data.
 *  
 *  @param aStream Stream to write to
 *  @capability None
 */
EXPORT_C void CSmsMessage::ExternalizeL(RWriteStream& aStream) const
	{
	LOGGSMU1("CSmsMessage::ExternalizeL()");

	ExternalizeWithoutBufferAndVersionL(aStream);
	ExternalizeBufferL(aStream);
	ExternalizeVersionL(aStream);

	if (iVersion > ESmsMessageV0)
		{
		iAdditionalInfo->ExternalizeL(aStream, iVersion);
		}
	} // CSmsMessage::ExternalizeL


/**
 *  Tests if the message contains text.
 *  
 *  @return True if the message contains text
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::TextPresent() const
	{
	LOGGSMU1("CSmsMessage::TextPresent()");

	CSmsPDU::TSmsPDUType pdutype=SmsPDU().Type();
	return (pdutype==CSmsPDU::ESmsSubmit) ||
	       (pdutype==CSmsPDU::ESmsDeliver) ||
	     (((pdutype==CSmsPDU::ESmsSubmitReport) || (pdutype==CSmsPDU::ESmsDeliverReport) ||
	      ((pdutype==CSmsPDU::ESmsStatusReport) && ((CSmsStatusReport&) SmsPDU()).ParameterIndicatorPresent())) &&
	      SmsPDU().UserDataPresent());
	} // CSmsMessage::TextPresent


/**
 *  Gets the number of PDU's required to encode the complete message.
 *  
 *  @leave KErrOverflow Leaves if the number of required PDUs exceeds the maximum
 *  or the message cannot be encoded.
 *  @return Number of PDU's
 *  @capability None
 */
EXPORT_C TInt CSmsMessage::NumMessagePDUsL()
	{
	LOGGSMU1("CSmsMessage::NumMessagePDUsL()");

	TInt nummessagepdus=1;
	if (IsDecoded())
		{
		if (TextPresent())
			{
			nummessagepdus=NumMessageEmsPDUsL();
			TInt maxnummessagepdus=SmsPDU().TextConcatenated()? 0xFF: 1;
 			if (nummessagepdus>maxnummessagepdus)
				{
 				User::Leave(KErrOverflow);
				}
			}

		}
	else if (TextPresent() && SmsPDU().TextConcatenated())
		{
		nummessagepdus=SmsPDU().NumConcatenatedMessagePDUs();
		}

	LOGGSMU2("CSmsMessage::NumMessagePDUsL() returns %d", nummessagepdus);

	return nummessagepdus;
	} // CSmsMessage::NumMessagePDUsL


/**
 *  Gets the maximum message length possible with the current settings.
 *  
 *  If Text is compressed, this returns the maximum number of bytes available
 *  with text compressed.
 *  
 *  @return Maximum message length
 *  @capability None
 */
EXPORT_C TInt CSmsMessage::MaxMessageLength() const
	{
	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));
	TInt maxmessagelength=SmsPDU().UserData().MaxBodyLengthInChars();
	if (SmsPDU().TextConcatenated())
		{
		maxmessagelength=maxmessagelength*0xFF;
		}

	LOGGSMU2("CSmsMessage::MaxMessageLength() returns %d", maxmessagelength);

	return maxmessagelength;
	} // CSmsMessage::MaxMessageLength


/**
 *  
 *  @return The converted buffer length
 *  @note Use with care - Expensive operation
 */
TInt CSmsMessage::ConvertedBufferLengthL(const CSmsBufferBase& aBuffer)
    {
    // Ignore in code coverage - not used in SMS stack and not exported
    // but cannot be removed as impacts public header.
    BULLSEYE_OFF    
    LOGGSMU1("CSmsMessage::ConvertedBufferLengthL()");
    
    TInt convertedBufferLength=0;
    CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(*iCharacterSetConverter,iFs,SmsPDU().Alphabet(),BinaryData());
    CSmsBufferSegmenter* segmenter=CSmsBufferSegmenter::NewLC(*converter,aBuffer);
    convertedBufferLength=segmenter->TotalConvertedLengthL(iAdditionalInfo->Alternative7bitEncoding());
    CleanupStack::PopAndDestroy(2, converter);
    
    LOGGSMU2("CSmsMessage::ConvertedBufferLengthL() returns %d", convertedBufferLength);
    
    return convertedBufferLength;
    BULLSEYE_RESTORE
    }

/**
 *  Gets the message length.
 *  
 *  In the case where the message is compressed, this function compresses the
 *  text and returns the number of bytes of the compressed buffer.
 *  
 *  The function calls ConvertedBufferLengthL(), and is therefore an expensive
 *  operation.
 *  
 *  @return Message length
 *  @capability None
 */
EXPORT_C TInt CSmsMessage::MessageLengthL()
	{
	LOGGSMU1("CSmsMessage::MessageLengthL()");

	TInt messagelength=0;
	if (!SmsPDU().TextCompressed())
		{
		messagelength=iBuffer->Length();
		if(SmsPDU().Alphabet() == TSmsDataCodingScheme::ESmsAlphabetUCS2)messagelength*=2 ;
		}
	else
		{
		User::Leave(KErrNotSupported);
		}
	return messagelength;
	} // CSmsMessage::MessageLengthL


EXPORT_C void CSmsMessage::GetEncodingInfoL(TInt& aPdus, TInt& aUnconvertedChars,
		                                    TInt& aDowngradedChars, TInt& aFreeUDUnitsInLastPDU)
	{
	LOGGSMU1("CSmsMessage::GetEncodingInfoL()");

	aPdus                 = 1;
	aUnconvertedChars     = 0;
	aDowngradedChars      = 0;
	aFreeUDUnitsInLastPDU = 0;

	if (TextPresent())
		{
		if (IsDecoded())
			{
			//
			// Clear the concatenated flag, EncodeBufferL() will add it if needed.
			//
			SmsPDU().SetTextConcatenatedL(EFalse, EFalse);

			//
			// Attempt to encode to a single PDU, and if that fails then attempt to
			// encode to a set of PDUs.
			//
			CArrayFixFlat<TGsmSms>*  tmpArray = new (ELeave) CArrayFixFlat<TGsmSms>(8);
			CleanupStack::PushL(tmpArray);
			
			//
			// Encode the message...
			//
			if (!EncodeIntoSinglePDUL(*tmpArray, aUnconvertedChars,
                                      aDowngradedChars, aFreeUDUnitsInLastPDU))
				{
				EncodeBufferL(*tmpArray, 0, *iBuffer, aUnconvertedChars,
						      aDowngradedChars, aFreeUDUnitsInLastPDU, EFalse);

				aPdus = iAdditionalInfo->SmsPDUArray().Count();
				if (aPdus > 255)
					{
	 				User::Leave(KErrOverflow);
					}
				}

			CleanupStack::PopAndDestroy(tmpArray);
			}
		else if (SmsPDU().TextConcatenated())
			{
			aPdus                 = SmsPDU().NumConcatenatedMessagePDUs();
			aUnconvertedChars     = 0;
			aDowngradedChars      = 0;
			aFreeUDUnitsInLastPDU = 0;
			}
		}

	LOGGSMU2("CSmsMessage::GetEncodingInfoL(): aPdus=%d", aPdus);
	LOGGSMU2("CSmsMessage::GetEncodingInfoL(): aUnconvertedChars=%d", aUnconvertedChars);
	LOGGSMU2("CSmsMessage::GetEncodingInfoL(): aDowngradedChars=%d", aDowngradedChars);
	LOGGSMU2("CSmsMessage::GetEncodingInfoL(): aFreeUDUnitsInLastPDU=%d", aFreeUDUnitsInLastPDU);
	} // CSmsMessage::GetEncodingInfoL


/**
 *  Gets the User Data Settings.
 *  
 *  @param aSettings User Data Settings
 *  @capability None
 */
EXPORT_C void CSmsMessage::UserDataSettings(TSmsUserDataSettings& aSettings) const
	{
	LOGGSMU1("CSmsMessage::UserDataSettings()");

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));
	aSettings.SetAlphabet(SmsPDU().Alphabet());
	aSettings.SetTextCompressed(SmsPDU().TextCompressed());
	TBool is16bit;
	TBool concatenated=SmsPDU().TextConcatenated(&is16bit);
	aSettings.SetTextConcatenated(concatenated,is16bit);
	} // CSmsMessage::UserDataSettings


/**
 *  Sets the User Data Settings.
 *  
 *  @param aSettings User Data Settings
 *  @capability None
 */
EXPORT_C void CSmsMessage::SetUserDataSettingsL(const TSmsUserDataSettings& aSettings)
	{
	LOGGSMU1("CSmsMessage::SetUserDataSettingsL()");

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));
	SmsPDU().SetAlphabet(aSettings.Alphabet());
	SmsPDU().SetTextCompressed(aSettings.TextCompressed());
	TBool is16bit;
	TBool concatenated=aSettings.TextConcatenated(&is16bit);
	SmsPDU().SetTextConcatenatedL(concatenated,is16bit);
	} // CSmsMessage::SetUserDataSettingsL


/**
 *  Optimizes the user data settings.
 *  
 *  The alphabet flag causes an alphabet to be chosen which preserves information
 *  in the message and makes the number of PDUs as small as possible.
 *  
 *  The compression settings flag is not supported.
 *  
 *  The compression flag causes compression to be switched on if the resultant
 *  number of PDUs is smaller.
 *  
 *  If user explicitly defines alphabet as UCS2 or 8-bit coding, this setting is preserved;
 *  otherwise, if 7-bit (default) alphabet can not support current text of message UCS2
 *  alphabet (Unicode) is used.
 *  
 *  The two concatenation flags are mutually exclusive as they deal with 8-bit
 *  and 16-bit referenced concatenation. Both flags cause compression to be switched
 *  off and if the message length is greater than the maximum message length,
 *  concatenation is switched on.
 *  
 *  @param aOptions Combination of TSmsOptimizationFlags
 *  @capability None
 */
EXPORT_C void CSmsMessage::OptimizeSettingsL(TInt aOptions)
	{
	LOGGSMU1("CSmsMessage::OptimizeSettingsL()");

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));
	__ASSERT_DEBUG(IsDecoded(),Panic(KGsmuPanicNotDecoded));

	if (aOptions&ESmsFlagOptimizeAlphabet && (SmsPDU().Alphabet()==TSmsDataCodingScheme::ESmsAlphabet7Bit))
		{
		TBool isSupported=ETrue;
		TInt numOfUnconvertibleChars;
		TInt indexOfFirstUnconvertibleChar;

		TInt size=iBuffer->Length();
		const TInt bufsize=128;
		TBuf<bufsize> buf;
		TInt extracted=0;
		TInt remaining=0;
		TInt toExtract=0;
		TInt pos=0;

		// Defect Fix. Previous for loop caused an access violation as extract size was set
		// to size of ibuffer not bufsize and caused a access violation when over 128. Implemented
		// fix copies the ibuffer in 128 chunks until its all done.

		while((pos<size) && isSupported)
			{
			remaining=(size - extracted);

			if(remaining>bufsize)
				toExtract=bufsize;
			else
				toExtract=remaining;

			iBuffer->Extract(buf,pos,toExtract);
			isSupported=IsSupportedL(buf,numOfUnconvertibleChars,indexOfFirstUnconvertibleChar);
			extracted=(extracted+toExtract);
			pos=extracted;
			}

		if(!isSupported)
			SmsPDU().SetAlphabet(TSmsDataCodingScheme::ESmsAlphabetUCS2);
		}
	} // CSmsMessage::OptimizeSettingsL


/**
 *  This function returns the currently requested alternative encoding method.
 * 
 *  In the case of incoming SMS messages received on the device, it will often
 *  be TSmsEncodingNone unless the Information Elements imply that an
 *  alternative encoding has been used.
 * 
 *  @return The currently selected encoding method.
 * 
 *  @capability None
 */
EXPORT_C TSmsEncoding CSmsMessage::Alternative7bitEncoding() const
	{
	LOGGSMU1("CSmsMessage::Alternative7bitEncoding()");

	return iAdditionalInfo->Alternative7bitEncoding();
	} // CSmsMessage::Alternative7bitEncoding


/**
 *  This function allows the client to specify an alternative encoding method
 *  incase the default GSM encoding cannot encode the message completely
 *  without data loss.
 * 
 *  @param aEncoding  Encoding method to select.
 * 
 *  @return A Symbian system wide error code.  This function will return
 *          KErrArgument if the encoding enum is invalid and will return
 *          KErrNotSupported if the required plug-ins are not present.
 * 
 *  @capability None
 */
EXPORT_C TInt CSmsMessage::SetAlternative7bitEncoding(TSmsEncoding aEncoding)
	{
	LOGGSMU2("CSmsMessage::SetAlternative7bitEncoding(%d)", aEncoding);

	//
	// Get the encoders that would be used for this encoding method.
	// The function will also check that the required encoder is present.
	//
	TRAPD(err,
		{
		CSmsAlphabetConverter*  converter = CSmsAlphabetConverter::NewLC(*iCharacterSetConverter, iFs,
																	     TSmsDataCodingScheme::ESmsAlphabet7Bit,
																	     EFalse);
		converter->ConfirmAlternativeEncoderL(aEncoding);
		CleanupStack::PopAndDestroy(converter);
		});
	
	//
	// Set the variable if the encoders are available...
	//
	if (err == KErrNone)
		{
		iAdditionalInfo->SetAlternative7bitEncoding(aEncoding);
		}
	
	return err;
	} // CSmsMessage::SetAlternative7bitEncoding


/**
 *  Takes an encoding setting (received from a PDU) and merges it into the
 *  current setting (where possible).
 *  
 *  @param aEncoding  Encoding setting to merge.
 */
void CSmsMessage::MergeAlternative7bitEncoding(TSmsEncoding aEncoding) const
	{
	LOGGSMU3("CSmsMessage::MergeAlternative7bitEncoding(): aEncoding=%d (currently %d)",
			 aEncoding, iAdditionalInfo->Alternative7bitEncoding());

	switch (iAdditionalInfo->Alternative7bitEncoding())
		{
		case ESmsEncodingNone:
			{
			// Anything is can be merge with this...
			iAdditionalInfo->SetAlternative7bitEncoding(aEncoding);
			}
			break;
		
		case ESmsEncodingTurkishSingleShift:
			{
			// Only Turkish locking shift can merge...
			if (aEncoding == ESmsEncodingTurkishLockingShift)
				{
				iAdditionalInfo->SetAlternative7bitEncoding(ESmsEncodingTurkishLockingAndSingleShift);
				}
			}
			break;
		
		case ESmsEncodingTurkishLockingShift:
			{
			// Only Turkish single shift can merge...
			if (aEncoding == ESmsEncodingTurkishSingleShift)
				{
				iAdditionalInfo->SetAlternative7bitEncoding(ESmsEncodingTurkishLockingAndSingleShift);
				}
			}
			break;
		
		case ESmsEncodingPortugueseSingleShift:
			{
			// Only Portuguese locking shift can merge...
			if (aEncoding == ESmsEncodingPortugueseLockingShift)
				{
				iAdditionalInfo->SetAlternative7bitEncoding(ESmsEncodingPortugueseLockingAndSingleShift);
				}
			}
			break;
		
		case ESmsEncodingPortugueseLockingShift:
			{
			// Only Portuguese single shift can merge...
			if (aEncoding == ESmsEncodingPortugueseSingleShift)
				{
				iAdditionalInfo->SetAlternative7bitEncoding(ESmsEncodingPortugueseLockingAndSingleShift);
				}
			}
			break;
		
		case ESmsEncodingTurkishLockingAndSingleShift:
		case ESmsEncodingSpanishSingleShift:
		case ESmsEncodingPortugueseLockingAndSingleShift:
		default:
			{
			// NOP - Cannot merge anything into these...
			}
		};

	LOGGSMU2("CSmsMessage::MergeAlternative7bitEncoding(): New encoding=%d",
			 iAdditionalInfo->Alternative7bitEncoding());
	} // CSmsMessage::MergeAlternative7bitEncoding


/**
 *  Tests if a buffer can be encoded without loss of information.
 *  
 *  @param aDes                                 The buffer to test for encoding
 *  @param aNumberOfUnconvertibleCharacters     On return, the number of 
 *                                              unconvertible characters
 *  @param aIndexOfFirstUnconvertibleCharacter  On return, the index of the
 *                                              first unconvertible character
 * 
 *  @return True if aDes can be encoded without loss of information
 * 
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,
		                                 TInt& aIndexOfFirstUnconvertibleCharacter)
	{
	LOGGSMU1("[1] CSmsMessage::IsSupportedL()");

	__ASSERT_DEBUG(TextPresent(), Panic(KGsmuPanicTextNotPresent));

	aNumberOfUnconvertibleCharacters    = 0;
	aIndexOfFirstUnconvertibleCharacter = aDes.Length();

	if (SmsPDU().TextCompressed())
		{
		return EFalse;
		}

	return SmsPDU().UserData().IsSupportedL(aDes, aNumberOfUnconvertibleCharacters,
                                            aIndexOfFirstUnconvertibleCharacter);
	} // CSmsMessage::IsSupportedL


/**
 *  Tests if a buffer can be encoded without loss of information.
 *  
 *  @param aDes                                 The buffer to test for encoding
 *  @param aNumberOfUnconvertibleCharacters     On return, the number of 
 *                                              unconvertible characters
 *  @param aNumberOfDowngradedCharacters        On return, the number of 
 *                                              characters downgraded
 *  @param aNumberRequiringAlternativeEncoding  On return, the number of 
 *                                              characters needing alternative
 *                                              encoding support
 *  @param aIndexOfFirstUnconvertibleCharacter  On return, the index of the
 *                                              first unconvertible character
 * 
 *  @return True if aDes can be encoded without loss of information
 * 
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,
		                                 TInt& aNumberOfDowngradedCharacters,
		                                 TInt& aNumberRequiringAlternativeEncoding,
		                                 TInt& aIndexOfFirstUnconvertibleCharacter) const
	{
	LOGGSMU1("[2] CSmsMessage::IsSupportedL()");

	__ASSERT_DEBUG(TextPresent(), Panic(KGsmuPanicTextNotPresent));

	aNumberOfUnconvertibleCharacters    = 0;
	aNumberOfDowngradedCharacters       = 0;
	aNumberRequiringAlternativeEncoding = 0;
	aIndexOfFirstUnconvertibleCharacter = aDes.Length();

	if (SmsPDU().TextCompressed())
		{
		return EFalse;
		}

	return SmsPDU().UserData().IsSupportedL(aDes, iAdditionalInfo->Alternative7bitEncoding(),
											aNumberOfUnconvertibleCharacters,
	                                        aNumberOfDowngradedCharacters,
                                            aNumberRequiringAlternativeEncoding,
                                            aIndexOfFirstUnconvertibleCharacter);
	} // CSmsMessage::IsSupportedL


/**
 *  Encodes message PDUs as an array of TGsmSms objects.
 *  
 *  Note, this function should only be called after EncodeIntoSinglePDUL() as EncodeBufferL() now
 *  automatically prepares PDUs for concatenation.
 *  
 *  @param aSmsArray (In) an empty array. On return, one or more encoded TGsmSms.
 *  @param aReference Sets a Concatenated Message Reference (default 0)
 *  @capability None
 */
EXPORT_C void CSmsMessage::EncodeMessagePDUsL(CArrayFix<TGsmSms>& aSmsArray, TInt aReference)
	{
	LOGGSMU2("CSmsMessage::EncodeMessagePDUsL(): aReference=%d", aReference);

	__ASSERT_DEBUG((aSmsArray.Count()==0),Panic(KGsmuPanicSmsArrayNotEmpty));
	
	if (TextPresent())
		{
		if (SmsPDU().TextCompressed())
			{
			User::Leave(KErrNotSupported);
			}
		else
			{
			TInt  unconvertedChars, downgradedChars, freeUDUnitsInLastPDU;
				
			EncodeBufferL(aSmsArray, aReference, *iBuffer, unconvertedChars,
					      downgradedChars, freeUDUnitsInLastPDU);
			}
		}
	else
		{
        if(SmsPDU().Type()==CSmsPDU::ESmsCommand)
            {
            //Commands never contain text, so commands only encoded
            // in this branch.
            //
            // However  Commands don't support information
            // elements (per 23.040 6.5) and the CSmsIEOperation class
            // do not allow control information elements to be added
            // to Commands, hence the next line is commented out.
            // PrepareCommandMessageL();
            }

 		TGsmSms sms;
 		SmsPDU().EncodeMessagePDUL(sms);
 		aSmsArray.AppendL(sms);
		}
	} // CSmsMessage::EncodeMessagePDUsL


/**
 *  @internalComponent
 *  
 *  This method copies information elements from the collections contained in
 *  CSmsMessageAdditionalAttributes into the working PDU.
 *  
 *  Command Messages comprise only 1 PDU. Therefore all information
 *  elements must be present in the working PDU when encoding takes place.
 *  If there is not enough space in the PDU, the message encoding will fail.
 *  
 *  The 23.040 has not defined any information elements that are contained in
 *  Command PDUs. This method has been provided to maintain consistency with
 *  previous GSMU implementations.
 *  
 *  @leave KErrAlreadyExists or KErrAlreadyExists
 */
void CSmsMessage::PrepareCommandMessageL()
    {
    LOGGSMU1("CSmsMessage::PrepareCommandMessageL()");

    if (SmsPDU().Type()==CSmsPDU::ESmsCommand)
        {
        CSmsCommand& command = static_cast<CSmsCommand&>(SmsPDU());

        for (TUint8 category = 0; category < TSmsInformationElementCategories::ENumberOfCategories; category++)
            {
            switch(category)
                {
                case TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly:
                case TSmsInformationElementCategories::ECtrlSingleInstanceOnly:
                case TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed:
                    {
                    for (TUint j = 0; j < iAdditionalInfo->NumberOfControlInformationElements((CSmsMessageAdditionalAttributes::TCategory) category); j++)
                        {
                        CSmsInformationElement& informationElement = iAdditionalInfo->GetControlInformationElementL( ( (CSmsMessageAdditionalAttributes::TCategory) category), j);
                        TPtr8 data = informationElement.Data();
                        command.AddInformationElementL(informationElement.Identifier(), data);
                        }
                    break;
                    }
                default:
                LOGGSMU2("CSmsMessage::PrepareCommandMessageL,default switch category = %d, id = %d", category);
                    break;
                }
            }
        }
    } // CSmsMessage::PrepareCommandMessageL


/**
 *  Decodes message PDUs from an array of TGsmSms objects.
 *  
 *  The array contains a concatenated message, and must have the correct number
 *  of PDUs.
 *  
 *  @param aSmsArray Concatenated message
 *  @capability None
 */
EXPORT_C void CSmsMessage::DecodeMessagePDUsL(const CArrayFix<TGsmSms>& aSmsArray)
	{
    LOGGSMU2("CSmsMessage::DecodeMessagePDUsL(): PDUs=%d", aSmsArray.Count());

	TInt count=aSmsArray.Count();
	SetIsComplete(ETrue);
	CArrayPtrFlat<CSmsPDU>* smspduarray=new(ELeave) CArrayPtrFlat<CSmsPDU>(8);
	CleanupStack::PushL(smspduarray);
	// With CleanupResetAndDestroyPushL, only ResetAndDestroy method of smspduarray is invoked. 
	// smspduarray object is actually deleted with the first push. 
	// coverity[double_push]
	CleanupResetAndDestroyPushL(*smspduarray);  // Don't forget to destroy what the array elements point to.

	TInt i=0;
	TBool ismobileterminated=(Type()==CSmsPDU::ESmsDeliver) || (Type()==CSmsPDU::ESmsSubmitReport) || (Type()==CSmsPDU::ESmsStatusReport);
	for (; i<count; i++)
		{
		CSmsPDU* smspdu=CSmsPDU::NewL(aSmsArray[i],*iCharacterSetConverter,iFs, EFalse,ismobileterminated);
		CleanupStack::PushL(smspdu);
		TInt j=0;
		for (; (j<smspduarray->Count()) && (smspdu->ConcatenatedMessagePDUIndex()>(*smspduarray)[j]->ConcatenatedMessagePDUIndex()); j++)
			{
			}
		smspduarray->InsertL(j,smspdu);
		CleanupStack::Pop();
		}
	if (SmsPDU().TextCompressed())
		User::Leave(KErrNotSupported);
	else
		DecodeBufferL(*smspduarray,*iBuffer);

	CleanupStack::PopAndDestroy(2);  //  smspduarray elements (Reset and Destroy), smspduarray
	SetIsDecoded(ETrue);
	SmsPDU().UserData().SetBodyL(KNullDesC8);
	} // CSmsMessage::DecodeMessagePDUsL

/**
 *  Decodes partial complete message PDUs from an array of TGsmSms objects.
 *  
 *  The array contains a concatenated incomplete message, but the array of
 *  TGsmSms object must be in sequence.
 *  
 *	NOTE:
 *	It will not fully decode EMS and Control Information elements if it needs 
 *	to decode a partially complete class 0 SMS message. The assumption is that 
 *	it is necessary to display a partially complete message then only the raw 
 *	text will be displayed on the UI without any animation elements. The 
 *	rational for this design is that these information elements are normally 
 *	specified as being located at a specific position in a message. It will 
 *	complicate the design of client app if it has to re-calculate the position 
 *	of these elements when it receives a partially complete message under 
 *	Out Of Memory Conditions.
 
 *  @param aSmsArray Concatenated message
 *	@param aLastPartialCompleteMsg boolean value indicating this is the last
 *			incomplete message for a particular concatenated message.
 *  @capability None
 */
EXPORT_C void CSmsMessage::DecodePartialCompleteMessagePDUsL(const CArrayFix<TGsmSms>& aSmsArray, TBool aLastPartialCompleteMsg)
	{
	LOGGSMU2("CSmsMessage::DecodePartialCompleteMessagePDUsL(): PDUs=%d", aSmsArray.Count());

	TInt count=aSmsArray.Count();
	SetIsComplete(EFalse);
	CArrayPtrFlat<CSmsPDU>* smspduarray=new(ELeave) CArrayPtrFlat<CSmsPDU>(8);
	CleanupStack::PushL(smspduarray);
	// With CleanupResetAndDestroyPushL, only ResetAndDestroy method of smspduarray is invoked. 
	// smspduarray object is actually deleted with the first push. 
	// coverity[double_push]
	CleanupResetAndDestroyPushL(*smspduarray);  // Don't forget to destroy what the array elements point to.

	TBool isMobileTerminated=(Type()==CSmsPDU::ESmsDeliver);
	/*
	The loop below goes through all the sms's received & check whether the received PDUs are of Class 0
	or not. The number of PDUs received must be less than the number of concatenated PDUs constitute this message.
	Then it order the PDUs in sequence for decoding purpose.
	*/
	for (TInt i=0; i<count; i++)
		{
		CSmsPDU* smspdu=CSmsPDU::NewL(aSmsArray[i],*iCharacterSetConverter,iFs, EFalse,isMobileTerminated);
		CleanupStack::PushL(smspdu);

		/*
		Check all the PDUs must be class 0 messages & also the number of received PDUs
		must be less than the number of concatenated PDUs constitute this message
		*/
		TSmsDataCodingScheme::TSmsClass  msgClass;
		if (smspdu->DataCodingSchemePresent()  &&  smspdu->Class(msgClass))
			{
			if (msgClass != TSmsDataCodingScheme::ESmsClass0)
				{
				User::Leave(KErrNotSupported);
				}
			__ASSERT_DEBUG((count < smspdu->NumConcatenatedMessagePDUs()),Panic(KGsmuPanicWrongNumberOfMessagePDUs));
			}
		else
			{
			User::Leave(KErrNotSupported);
			}
		//The below for statement finds the position in smspduarray where the PDU should be inserted.
		//The PDUs are put in sequence for decoding purpose.
		TInt j;
		for (j=0; (j<smspduarray->Count()) && (smspdu->ConcatenatedMessagePDUIndex()>(*smspduarray)[j]->ConcatenatedMessagePDUIndex()); j++)
			{
			}
		smspduarray->InsertL(j,smspdu);
		CleanupStack::Pop();
		}

	if (SmsPDU().TextCompressed())
		{
		User::Leave(KErrNotSupported);
		}
	else
		{
		DecodeOnlyTextL(*smspduarray,*iBuffer);
		}

	iVersion = CSmsMessage::ESmsIncompleteClass0MessageV;

	TInt startPDU = smspduarray->At(0)->ConcatenatedMessagePDUIndex();
	TInt endPDU = smspduarray->At(smspduarray->Count()-1)->ConcatenatedMessagePDUIndex();
	AddIncompleteMessageInfoL(startPDU, endPDU, aLastPartialCompleteMsg);

	CleanupStack::PopAndDestroy(2);  //  smspduarray elements (Reset and Destroy), smspduarray
	SetIsDecoded(ETrue);
	SmsPDU().UserData().SetBodyL(KNullDesC8);	
	}

CSmsMessage::CSmsMessage(RFs& aFs, CSmsBufferBase* aBuffer):
    iFlags(0),
    iStatus(NMobileSmsStore::EStoredMessageUnread),
    iLogServerId(KLogNullId),
    iBuffer(aBuffer),
    iFs(aFs),
	iSlotArray(8),
	iVersion(ESmsMessageV4),
	iAdditionalInfo(NULL)
    {
    iTime.UniversalTime();

    TBool result = SetUTCOffset(User::UTCOffset());
    __ASSERT_DEBUG(result, Panic(KGSMUPanicUserTimeZoneOffsetOutOfRange));
    } // NMobileSmsStore::EStoredMessageUnread

void CSmsMessage::ConstructL(const TGsmSms& aGsmSms, TBool aIsRPError,TBool aIsMobileTerminated)
	{
    LOGGSMU1("CSmsMessage::ConstructL()");

	iCharacterSetConverter=CCnvCharacterSetConverter::NewL();
	iInformationElementArray = new (ELeave) RPointerArray<CEmsInformationElement>(8);

	iAdditionalInfo = CSmsMessageAdditionalAttributes::NewL();
	CreateControlIEOperationsClassesL();
	CreateControlNonIEOperationsClassesL();

	iSmsPDU=CSmsPDU::NewL(aGsmSms,*iCharacterSetConverter,iFs, aIsRPError,aIsMobileTerminated);
	SetIsComplete(NumMessagePDUsL()==1);
	if (IsComplete() && TextPresent())
		{
		TSmsEncoding  encodingUsedInSegment = SmsPDU().NationalLanguageEncoding();
		
		CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(*iCharacterSetConverter,iFs,SmsPDU().Alphabet(),BinaryData());
		TPtrC nativeChars(converter->ConvertToNativeL(SmsPDU().UserData().Body(),
													  encodingUsedInSegment));
		MergeAlternative7bitEncoding(encodingUsedInSegment);
		
		if (SmsPDU().TextCompressed())
			User::Leave(KErrNotSupported);
		else
			iBuffer->InsertL(iBuffer->Length(),nativeChars);
		CleanupStack::PopAndDestroy(converter);
		CSmsPDU::TSmsPDUType pdutype= SmsPDU().Type();
		if(pdutype==CSmsPDU::ESmsCommand)
			{
			// This branch is never executed as TextPresent() never
			// returns true when pduType == command
            User::Leave(KErrArgument);
			}
		else if(SmsPDU().UserDataPresent())
			{
			TInt smscIndex(0);

			if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEISMSCControlParameters,smscIndex))
				{
				iAdditionalInfo->SetStatusReportSchemeL(EControlParametersScheme);
				}
			else
				{
				iAdditionalInfo->SetStatusReportSchemeL(EDefaultScheme);	
				}
				
            InstallControlInformationElementsL(SmsPDU().UserData(), 0);
			InstallEmsInformationElementsL(SmsPDU().UserData(),0);
			UpdateUserPromptAndODIElementsStartPosition();
			}
		}
	SetIsDecoded(IsComplete());

	if (TextPresent())
		SmsPDU().UserData().SetBodyL(KNullDesC8);
	} // CSmsMessage::ConstructL


void CSmsMessage::ConstructL(CSmsPDU::TSmsPDUType aType,TBool aIsRPError)
	{
    LOGGSMU3("CSmsMessage::ConstructL(): aType=%d, aIsRPError=%d", (TInt) aType,
    		 aIsRPError);

	iCharacterSetConverter=CCnvCharacterSetConverter::NewL();
	iInformationElementArray = new (ELeave) RPointerArray<CEmsInformationElement>(2);

	iAdditionalInfo = CSmsMessageAdditionalAttributes::NewL();
	CreateControlIEOperationsClassesL();
	CreateControlNonIEOperationsClassesL();

	iSmsPDU=CSmsPDU::NewL(aType,*iCharacterSetConverter,iFs,aIsRPError);
	SetIsComplete(ETrue);
	SetIsDecoded(ETrue);
	} // CSmsMessage::ConstructL


/**
 *  Counts the number of PDUs that this message will take. To do this the
 *  message will attempt to be encoded into 1 message, and if not into
 *  multiple messages. Due to the processing, the function should be used
 *  sparingly.
 * 
 *  @return  Number of PDUs required.
 */
TInt CSmsMessage::NumMessageEmsPDUsL()
	{
	LOGGSMU1("CSmsMessage::NumMessageEmsPDUsL()");

	//
	// Clear the concatenated flag, EncodeBufferL() will add it if needed.
	//
	SmsPDU().SetTextConcatenatedL(EFalse, EFalse);

	//
	// Attempt to encode to a single PDU, and if that fails then attempt to
	// encode to a set of PDUs.
	//
	CArrayFixFlat<TGsmSms>*  tmpArray = new (ELeave) CArrayFixFlat<TGsmSms>(8);
	CleanupStack::PushL(tmpArray);
	TInt numMsgs = 1;
	
	if (!EncodeIntoSinglePDUL(*tmpArray))
		{
		TInt  unconvertedChars, downgradedChars, freeUDUnitsInLastPDU;
		
		EncodeBufferL(*tmpArray, 0, *iBuffer, unconvertedChars,
			          downgradedChars, freeUDUnitsInLastPDU, EFalse);

		numMsgs = iAdditionalInfo->SmsPDUArray().Count();
		}

	CleanupStack::PopAndDestroy(tmpArray);
	
    LOGGSMU2("CSmsMessage::NumMessageEmsPDUsL() returns %d", numMsgs);

	return numMsgs;
	} // CSmsMessage::NumMessageEmsPDUsL


/**
 *  @internalComponent
 *  
 *  This method removes all non mandatory information elements from the
 *  working PDU.
 *  
 *  The working PDU is the PDU which is currently being encoded or decoded.
 *  
 *  @leave KErrAlreadyExists or KErrAlreadyExists
 */
void CSmsMessage::ResetWorkingPDUL()
	{
	LOGGSMU1("CSmsMessage::ResetWorkingPDUL()");
	
	CSmsUserData& uData = SmsPDU().UserData();
	//remove non-mandatory EMS information elements
	for (TInt a=uData.NumInformationElements(); a>0; --a)
        {
        const CSmsInformationElement& ie = uData.InformationElement(a-1);

         TSmsInformationElementCategories::TInformationElementCategory category;

        if (TSmsInformationElementCategories::GetCategoryDefinition(ie.Identifier(), category)  &&
        	(category !=  TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUAndWithIdenticalValues)    &&
            (category !=  TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU) &&
            (category !=  TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUMultipleInstancesPerPDU))
            {
            uData.RemoveInformationElement(a-1);
            }
        }
    // reset user body
    uData.SetBodyL(KNullDesC8);
    } // CSmsMessage::ResetWorkingPDUL


void CSmsMessage::CorrectFormattingL(TUint aCharsAddedToCurrentPDU,
									 RPointerArray<CEmsInformationElement>& aCorrectedFormattingIEArray,
									 TUint aCharsAlreadyAdded)
	{
	LOGGSMU3("CSmsMessage::CorrectFormattingL(): aCharsAddedToCurrentPDU=%d, aCharsAlreadyAdded=%d",
			 aCharsAddedToCurrentPDU, aCharsAlreadyAdded);

	CSmsUserData& uData = SmsPDU().UserData();
	for (TInt a= 0; a < uData.NumInformationElements(); a++)
		{
		CSmsInformationElement& ie = uData.InformationElement(a);
		if (CSmsInformationElement::ESmsEnhancedTextFormatting==ie.Identifier())
			{
			CEmsFormatIE& formatIE=static_cast<CEmsFormatIE&>(ie);

			TUint oldFormatLen=formatIE.FormatLength(); //
			if(aCharsAddedToCurrentPDU < formatIE.StartPosition() + oldFormatLen)
				{
				TUint newFormatLen=aCharsAddedToCurrentPDU - formatIE.StartPosition();
				formatIE.SetFormatLength(newFormatLen);

				// Now, re-encode the information element - this is because we have
				// changed a message in the UserData which is using EMS elements as
				// SMS IEs. Encoding is NOT automatic
				formatIE.EncodeInformationElementL();

				if((TInt)(aCharsAlreadyAdded+aCharsAddedToCurrentPDU) < iBuffer->Length())
					{
					CEmsFormatIE* newie=static_cast<CEmsFormatIE*>(formatIE.DuplicateL());
					CleanupStack::PushL(newie);
					newie->SetFormatLength(oldFormatLen - newFormatLen);
					newie->SetStartPosition(aCharsAlreadyAdded+aCharsAddedToCurrentPDU);
					LOGGSMU2("CSmsMessage::CorrectFormattingL",aCorrectedFormattingIEArray.Count());
					aCorrectedFormattingIEArray.Append(newie);
					CleanupStack::Pop(newie);
					}
				}
			}
		}
	} // CSmsMessage::CorrectFormattingL


void CSmsMessage::CorrectFormattingInSinglePDUL()
	{
	LOGGSMU1("CSmsMessage::CorrectFormattingInSinglePDUL()");

	CSmsUserData& uData = SmsPDU().UserData();
	for (TInt a= 0; a < uData.NumInformationElements(); a++)
		{
		CSmsInformationElement& ie = uData.InformationElement(a);
		if (CSmsInformationElement::ESmsEnhancedTextFormatting==ie.Identifier())
			{
			CEmsFormatIE& formatIE=static_cast<CEmsFormatIE&>(ie);
			TUint oldFormatLen=formatIE.FormatLength(); //
			if(iBuffer->Length() < (TInt)(formatIE.StartPosition()+ oldFormatLen))
				{
				TUint newFormatLen=iBuffer->Length() - formatIE.StartPosition();
				formatIE.SetFormatLength(newFormatLen);

				// reencode
				formatIE.EncodeInformationElementL();
				}
			}
		}
	} // CSmsMessage::CorrectFormattingInSinglePDUL


/**
 *  Adds a copy of the current PDU to the PDU array used to record all the
 *  PDUs being encoded in a concatentated message.
 * 
 *  @param  aDoEncode  If true the PDU is added and updated. If false only a
 *                     NULL placeholder is stored. This allows the number of
 *                     PDUs to be quickly counted if the encoded PDUs are of
 *                     no further use.
 */
void CSmsMessage::AddCurrentPDUToPDUArrayL(TBool aDoEncode)
	{
	LOGGSMU2("CSmsMessage::AddCurrentPDUToPDUArrayL(): Adding PDU number %d",
			 iAdditionalInfo->SmsPDUArray().Count() + 1);
	
	//
	// Maximum number of PDU is 255, so if we have that already then we cannot
	// continue.
	//
	TInt  numPDUs = iAdditionalInfo->SmsPDUArray().Count();

	if (numPDUs >= 255)
		{
		User::Leave(KErrOverflow);
		}
	
	//
	// We only do most of the work if we are actually encoding.
	//
	if (aDoEncode)
		{
		//
		// Update the Concatenated Message PDU numbers in the current PDU. This
		// means that at least the last PDU has the correct values (to update
		// all PDUs when a new PDU is added would be too slow, so we do that
		// only once at the end).
		//
		if (numPDUs > 0)
			{
			SmsPDU().SetConcatenatedMessagePDUIndex(numPDUs+1);
			SmsPDU().SetNumConcatenatedMessagePDUs(numPDUs+1);
			}
	
		//
		// Create copy of the current PDU and store it in the array...
		//
		CSmsPDU*  newPDU = SmsPDU().DuplicateL();
		CleanupStack::PushL(newPDU);
		iAdditionalInfo->SmsPDUArray().AppendL(newPDU);
		CleanupStack::Pop(newPDU);
		}
	else
		{
		//
		// Otherwise just append a NULL value to allow the data PDUs to be
		// counted...
		//
		iAdditionalInfo->SmsPDUArray().AppendL(NULL);
		}
	} // CSmsMessage::AddCurrentPDUToPDUArrayL


TBool CSmsMessage::AddIEToUserDataL(CEmsInformationElement* aIE, TInt aCharsAlreadyAdded,TUint& aCharsAddedToCurrentPDU,CSmsEMSBufferSegmenter& aSeg)
	{
	LOGGSMU1("CSmsMessage::AddIEToUserDataL()");

	TBool ieAdded=EFalse;
	if (SmsPDU().UserData().EmsInformationElementWillFitL(aIE,aSeg,aCharsAddedToCurrentPDU))
		{
		CEmsInformationElement* newIE=aIE->DuplicateL();
		newIE->SetStartPosition(newIE->StartPosition()-aCharsAlreadyAdded);
	    CleanupStack::PushL(newIE);
		SmsPDU().UserData().AddEmsInformationElementL(newIE);
		CleanupStack::Pop(newIE);
		ieAdded=ETrue;
		}
	return ieAdded;
	} // CSmsMessage::AddIEToUserDataL


/**
 *  Fills the current PDU with the number of specified native chars.
 *  
 *  @param aSeg Buffer containing the native chars
 *  @param aNumChars number of native characters to add.
 *  @param aEncoding  SMS Encoding if required.
 * 
 *  @return TInt Number of native characters added
 */
TInt CSmsMessage::FillPduL(CSmsEMSBufferSegmenter& aSeg, TInt aNumChars, TSmsEncoding aEncoding)
	{
	LOGGSMU1("CSmsMessage::FillPduL()");

	TUint maxUDUnitsREmaining=SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();

	if (aNumChars==0 || maxUDUnitsREmaining==0)
		{
		return 0;
		}

	HBufC8* buf=HBufC8::NewMaxLC(2*aNumChars);
	TPtr8 ptr(buf->Des());
	TInt numberOfUnconvertibleCharacters(0); 
	TInt numberOfDowngradedCharacters(0);

	TInt nativeLength = aSeg.SegmentL(ptr, aNumChars, maxUDUnitsREmaining,
			                          numberOfUnconvertibleCharacters,
			                          numberOfDowngradedCharacters,
			                          aEncoding);

	SmsPDU().UserData().AppendBodyL(ptr);

	CleanupStack::PopAndDestroy(buf);
	return nativeLength;
	} // CSmsMessage::FillPduL


/**
 *  This method copies control information elements from the specified
 *  collection into the working PDU.
 *  
 *  @param aCategory        The category of control information element to be
 *                          added to the PDU.
 *  @param aMandatoryInPDU  Specifies whether the specified category of information
 *                          element must be added to this PDU.
 *  @param aDoEncode        Flag indicating if encoding is really wanted, or just the
 *                          calculation of the number of PDUs.
 *
 *  @leave KErrArgument     If the category is mandatory but one or more elements
 *                          cannot be added then the encoding will fail.
 *  @leave KErrOverFlow     If the information element is too big to be encoded into
 *                          a PDU that contains only the mandatory elements.
 */
void CSmsMessage::AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::TInformationElementCategory aCategory,
			                                                          TBool aMandatoryInPDU, TBool aDoEncode)
    {
    LOGGSMU1("CSmsMessage::AddControlInformationElementsToMultiSegmentMessageL()");

    TUint numberOfInformationElements = iAdditionalInfo->NumberOfControlInformationElements(aCategory);

    for (TInt i = 0; i < numberOfInformationElements; i++)
        {
        CSmsInformationElement& informationElement = iAdditionalInfo->GetControlInformationElementL( aCategory, i);

        CSmsInformationElement* cloneInformationElement = CSmsInformationElement::NewL(informationElement.Identifier(),informationElement.Data());
        CleanupStack::PushL(cloneInformationElement);

        if (SmsPDU().UserData().ControlInformationElementWillFitL(cloneInformationElement))
            {
            SmsPDU().UserData().UpdateInformationElementArrayL(informationElement.Identifier(),informationElement.Data());
            }
        else if (aMandatoryInPDU)
                {
                // Error Scenario, cannot fit the mandatory PDU into the User Data
                User::Leave(KErrArgument);
                }
             else
                {
                // Close off PDU and transfer to output array
                AddCurrentPDUToPDUArrayL(aDoEncode);
                ResetWorkingPDUL();

                // Now test whether the information element will fit into a PDU at all.
                // It is possible to make Enhanced Voice Mail Information Elements
                // bigger than the available space in the PDU.
                TBool canFit = SmsPDU().UserData().ControlInformationElementWillFitL(cloneInformationElement);
                if (canFit == EFalse)
                    {
                    LOGGSMU1("CSmsMessage::AddControlInformationElementsToMultiSegmentMessage, IE too bit to fit in any PDUL");
                    User::Leave(KErrArgument);
                    }
                i--;
                }

        CleanupStack::PopAndDestroy(cloneInformationElement);
        }
    } // CSmsMessage::AddControlInformationElementsToMultiSegmentMessageL


/**
 *  This method copies control information elements from the collections of
 *  control information elements contained in CSmsAdditionalAttributes into the
 *  working PDU.
 *  
 *  @param aDoEncode  Flag indicating if encoding is really wanted, or just the
 *                    calculation of the number of PDUs.
 *
 *  @leave KErrArgument  If the category is mandatory but one or more elements
 *                       cannot be added then the encoding will fail.
 */
void CSmsMessage::AddControlInformationElementsToMultiSegmentMessageL(TBool aDoEncode)
    {
    LOGGSMU1("CSmsMessage::AddControlInformationElementsToMultiSegmentMessageL() 1");

    TBool mandatoryInEachPDU = ETrue;
    AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly,
    													mandatoryInEachPDU, aDoEncode);
    mandatoryInEachPDU = EFalse;
    AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::ECtrlSingleInstanceOnly,
    													mandatoryInEachPDU, aDoEncode);
    AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed,
    													mandatoryInEachPDU, aDoEncode);
    } // CSmsMessage::AddControlInformationElementsToMultiSegmentMessageL


/**
 *  Attempts to add EMS IE to the current PDU.
 *  
 *  @param aSegmenter                  Reference to buffer segmenter.
 *  @param aCharsAddedToCurrentPDU     Returned number of characters added to current PDU.
 *  @param aDoEncode                   Flag indicating if encoding is really wanted,
 *                                     or just the calculation of the number of PDUs.
 *  @param aEncoding                   SMS 7bit encoding if appropriate.
 *  @param aCorrectedFormatingIEArray  Array of IEs that have to be placed in following
 *                                     PDUs (e.g. corrected).
 *  @param aCurrEMSIEno                Current IE number.
 *  @param aCharsAlreadyAdded          Returned number of characters added.
 *
 *  @return Whether EMS IE has beenn added, in singleMode returns true if there are no more than one PDU.
 */
TBool CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL(CSmsEMSBufferSegmenter& aSegmenter,
																   TUint& aCharsAddedToCurrentPDU,
																   TBool aDoEncode,
																   TSmsEncoding& aEncoding,
																   RPointerArray<CEmsInformationElement>& aCorrectedFormatingIEArray,
																   TUint& aCurrEMSIEno,
																   TUint& aCharsAlreadyAdded)
	{
	LOGGSMU1("CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL()");

	TUint startPosition=0;

	 // number of chars added to the current PDU
	TUint no=iInformationElementArray->Count();
	LOGGSMU2("CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL no of IE %d",no);
	CEmsInformationElement* ie = NULL;
	TUint msgLen=iBuffer->Length();
	TUint filledChars=0;

	while(aCurrEMSIEno < no || aCorrectedFormatingIEArray.Count() > 0)
	{
		ie = NULL;
		TBool correction=EFalse;
		if(aCurrEMSIEno < no)
			{
			ie = (*iInformationElementArray)[aCurrEMSIEno];
			startPosition=ie->StartPosition();
			}

		if(ie == NULL || ( startPosition != aCharsAlreadyAdded) )
		{
			if(aCorrectedFormatingIEArray.Count() > 0)
			{
				correction=ETrue;
				ie = aCorrectedFormatingIEArray[0];
				startPosition=ie->StartPosition();
			}
		}

		__ASSERT_DEBUG(ie !=NULL, User::Leave(KErrCorrupt));

		if(startPosition <= msgLen)
			{
			__ASSERT_DEBUG(startPosition>=aCharsAlreadyAdded, User::Leave(KErrUnderflow));
			startPosition -= aCharsAlreadyAdded; // startPosition now relative to current PDU.

			// Add all chars upto startposition.
			filledChars=0;

			if(startPosition > aCharsAddedToCurrentPDU)
				{
				filledChars = FillPduL(aSegmenter, startPosition-aCharsAddedToCurrentPDU, aEncoding);
				aCharsAddedToCurrentPDU+=filledChars;
				}

			LOGGSMU2("CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL: filled %d chars", filledChars);

			if (aCharsAddedToCurrentPDU==startPosition)
				{
				// Try adding the IE.
				if (AddIEToUserDataL(ie, aCharsAlreadyAdded,aCharsAddedToCurrentPDU,aSegmenter))
					{
					if(correction)
					{
						aCorrectedFormatingIEArray.Remove(0);
						// aCorrectedFormatingIEArray[0] has been removed. In next loop, ie will point another element. So there is no double free.
						// coverity[double_free]
						delete ie;
						correction=EFalse;
					}
					else aCurrEMSIEno++;
					}
				else
					{
					// Information Element will not fit send PDU
					LOGGSMU1("CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL: ie will not fit send Message");
					CorrectFormattingL(aCharsAddedToCurrentPDU,aCorrectedFormatingIEArray,aCharsAlreadyAdded);

					aCharsAlreadyAdded += aCharsAddedToCurrentPDU;
					aCharsAddedToCurrentPDU=0;

					AddCurrentPDUToPDUArrayL(aDoEncode);
					ResetWorkingPDUL();

					//
					// Find the encoding method for the next segment...
					//
					//aEncoding = ESmsEncodingNone;
					//TRAP_IGNORE(aEncoding = aSegmenter->FindBestAlternativeEncodingL(iAdditionalInfo->iAlternative7bitEncoding,
					//												                   maxBodyLength));
					SmsPDU().SetNationalLanguageEncodingL(aEncoding);
					}
				}
			else
				{
				// native chars upto start position will not fit send PDu.
				LOGGSMU1("CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL: PDU is filled with chars sending");

				CorrectFormattingL(aCharsAddedToCurrentPDU,aCorrectedFormatingIEArray,aCharsAlreadyAdded);

				aCharsAlreadyAdded += aCharsAddedToCurrentPDU;
				aCharsAddedToCurrentPDU=0;

				AddCurrentPDUToPDUArrayL(aDoEncode);
				ResetWorkingPDUL();

				//
				// Find the encoding method for the next segment...
				//
				//aEncoding = ESmsEncodingNone;
				//TRAP_IGNORE(aEncoding = aSegmenter->FindBestAlternativeEncodingL(iAdditionalInfo->iAlternative7bitEncoding,
				//												                   maxBodyLength));
				SmsPDU().SetNationalLanguageEncodingL(aEncoding);
				}
			}
		else
			{
			aCurrEMSIEno++;
			}
		}		// end of while loop for all IEs

	return ETrue;
	} // CSmsMessage::AddEMSInformationElementsToMultiSegmentMessageL


/**
 *  Attempts to add EMS IE to the current PDU
 *  
 *  @param aSegmenter
 *  @return TBool whether EMS IEs have been added to segment
 */
TBool CSmsMessage::AddEMSInformationElementsToSingleSegmentMessageL(CSmsEMSBufferSegmenter& aSegmenter,
																	TSmsEncoding aEncoding)
	{
	LOGGSMU1("CSmsMessage::AddEMSInformationElementsToSingleSegmentMessageL()");

	TUint charsAddedToCurrentPDU=0;
	TUint numOfEmsIE=iInformationElementArray->Count();
	TUint currEmsIEindex=0;
	CEmsInformationElement* ie = NULL;
	TUint startPosition=0;
	TUint filledChars=0;

	while(currEmsIEindex < numOfEmsIE)
		{
		ie = (*iInformationElementArray)[currEmsIEindex];
		startPosition=ie->StartPosition();

		if (startPosition > charsAddedToCurrentPDU)
			{
			filledChars = FillPduL(aSegmenter, startPosition-charsAddedToCurrentPDU, aEncoding);
			charsAddedToCurrentPDU+=filledChars;
			}

		if (charsAddedToCurrentPDU != startPosition ||
			!AddIEToUserDataL(ie, 0,charsAddedToCurrentPDU,aSegmenter))
			{
			return EFalse;
			}

		++currEmsIEindex;
		}

	return ETrue;
	} // CSmsMessage::AddEMSInformationElementsToSingleSegmentMessageL


/**
 *  Encode the PDU into an TGsmSms array. The Text and the EMS objects are
 *  laid out with respect to start position locations and encoded into the
 *  correct TGsmSms object.
 *  
 *  @leave KErrUnderflow if the Ems objects are not in Start position order.
 *
 *  @param aSmsArray               Returned array of newly created TSms objects
 *                                 containing the encoded message.
 *  @param aReference              Unique reference number to be given to the
 *                                 TGsmSms objects.
 *  @param aBuffer                 Body Text buffer of the message.
 *  @param aUnconvertedChars       Exit param for the number of characters not converted.
 *  @param aDowngradedChars        Exit param for the number of characters downgraded.
 *  @param aFreeUDUnitsInLastPDU   Exit param for the number of characters free
 *                                 in the last PDU.
 *  @param aDoEncode               Flag indicating if encoding is really wanted,
 *                                 or just the calculation of the number of PDUs.
 */
void CSmsMessage::EncodeBufferL(CArrayFix<TGsmSms>& aSmsArray, TInt aReference,
								const CSmsBufferBase& aBuffer,
								TInt& aUnconvertedChars, TInt& aDowngradedChars,
						        TInt& aFreeUDUnitsInLastPDU, TBool aDoEncode)
	{
	LOGGSMU1("CSmsMessage::EncodeBufferL()");

	aUnconvertedChars     = 0;
	aDowngradedChars      = 0;
	aFreeUDUnitsInLastPDU = 0;
	
	//
	// Reset the working array of PDUs...
	//
	iAdditionalInfo->SmsPDUArray().ResetAndDestroy();

	TUint currEMSIEno(0);
	
	TInt smscIndex(0);
	TBool smscPresent(EFalse);
	
	TInt emailOverallHeaderLength(0);
	TInt emailIndex(0);
	TBool emailPresent(EFalse);
	
	if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEISMSCControlParameters,smscIndex))
		{
		smscPresent=ETrue;
		}
	if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEIRFC822EmailHeader,emailIndex))
		{
		emailPresent=ETrue;
		emailOverallHeaderLength=SmsPDU().UserData().InformationElement(emailIndex).Data()[0];
		}

	//
	// Create Array for corrected format elements. These will be elements that
	// have to be moved into subsequent PDUs due to lack of space in the
	// current PDU.
	//
	RPointerArray<CEmsInformationElement>  correctedFormatingIEArray(2);
	CleanupResetAndDestroyPushL(correctedFormatingIEArray);

	//
	// Reset the working PDU. This safes time be keeping fields we need and
	// droping any data from previous PDUs.
	//
	ResetWorkingPDUL();

	//
	// Automatically prepare for concatenation (any single PDU messages would
	// have been handled by EncodeIntoSinglePDUL() previously).
	//
	SmsPDU().SetTextConcatenatedL(ETrue,iIs16BitConcatenation);

	TInt maxBodyLength=SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();

	//
	// Add any elements that are required to be present, and ensure they
	// have correct data stored (for example if we are recycling the working PDU).
	//
	AddControlInformationElementsToMultiSegmentMessageL(aDoEncode);

	//
	// Create EMS Segmenter and Buffer Converter...
	//
	CSmsAlphabetConverter*  converter = CSmsAlphabetConverter::NewLC(*iCharacterSetConverter, iFs,SmsPDU().Alphabet(),
			                                                         BinaryData());
	CSmsEMSBufferSegmenter*  segmenter = CSmsEMSBufferSegmenter::NewLC(*converter, aBuffer, maxBodyLength);
	TBool  isUnicode = (SmsPDU().Alphabet() == TSmsDataCodingScheme::ESmsAlphabetUCS2);

	TBool informationToSend     = ETrue;
	TUint charsAdded2CurrentPDU = 0;
	TUint charsAlreadyAdded     = 0;

	//
	// Find the best alternative encoding for the current segment. This will be
	// set at the beginning of each PDU using the list of encoders.
	//
	TSmsEncoding  encodingToUse = ESmsEncodingNone;

	TRAP_IGNORE(encodingToUse = segmenter->FindBestAlternativeEncodingL(iAdditionalInfo->Alternative7bitEncoding(),
													                    aBuffer.Length()));
	SmsPDU().SetNationalLanguageEncodingL(encodingToUse);
	
	//
	// If there are information elements to add, add them to the first PDU (or
	// to the correct formatting array for later PDUs if more appropriate).
	//
	if(iInformationElementArray->Count() >0)
		{
		AddEMSInformationElementsToMultiSegmentMessageL(*segmenter, charsAdded2CurrentPDU,
														aDoEncode, encodingToUse,
														correctedFormatingIEArray,
														currEMSIEno, charsAlreadyAdded);
		}

	//
	// Allocate a temporary buffer to work with...
	//
	HBufC8* buf=HBufC8::NewMaxLC(maxBodyLength);
	TPtr8 ptr(buf->Des());

	//
	// While there is still data to encode see how much space is left in this
	// PDU and attempt to encode something into it...
	//
	while (segmenter->MoreL())
			{
			LOGGSMU1("CSmsMessage::EncodeBufferL - there is MoreL");
			
			//
			// Calculate the space left to use in this PDU...
			//
			TInt size = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
			LOGGSMU2("CSmsMessage::EncodeBufferL - remaining size in PDU is %d",size);

			//
			// While there is no space, correct the formatting (which may
			// introduce any un-placed EMS Elements into the corrected format
			// array) and then start a new PDU...
			//
			while (size==0)
				{
				//
				// Store any elements not yet placed into the array for later...
				//
				CorrectFormattingL(charsAdded2CurrentPDU, correctedFormatingIEArray, charsAlreadyAdded);

				//
				// Store this PDU, reset the working PDU and get ready to
				// continue with the next PDU...
				//
				aFreeUDUnitsInLastPDU = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
				AddCurrentPDUToPDUArrayL(aDoEncode);
				ResetWorkingPDUL();
				informationToSend=EFalse;
				charsAlreadyAdded+=charsAdded2CurrentPDU;
				charsAdded2CurrentPDU=0;

				//
				// Find the encoding method for the next segment...
				//
				//encodingToUse = ESmsEncodingNone;
				//TRAP_IGNORE(encodingToUse = segmenter->FindBestAlternativeEncodingL(iAdditionalInfo->iAlternative7bitEncoding,
				//												                    maxBodyLength));
				SmsPDU().SetNationalLanguageEncodingL(encodingToUse);

				//
				// Add any elements that can be placed now (from previous
				// PDUs and above)... 
				//
				LOGGSMU3("CSmsMessage::EncodeBufferL: IE count  %d corrected  count %d",iInformationElementArray->Count(),correctedFormatingIEArray.Count() );
				if ((TUint)iInformationElementArray->Count() > currEMSIEno  ||
					correctedFormatingIEArray.Count() > 0)
					{
					AddEMSInformationElementsToMultiSegmentMessageL(*segmenter,charsAdded2CurrentPDU,
																	aDoEncode, encodingToUse,
																	correctedFormatingIEArray,
																	currEMSIEno,charsAlreadyAdded);
					}

				//
				// Calculate the space left remaining in this new PDU...
				//
				size = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
				LOGGSMU2("CSmsMessage::EncodeBufferL - remaining size in PDU is %d",size);
				}
			
			//
			// We have space in this PDU and no elements to place, so obtain
			// the next peice of text that can fit and append it.
			//
			segmenter->SegmentNextL(ptr, size, aUnconvertedChars, aDowngradedChars, encodingToUse);
			SmsPDU().UserData().AppendBodyL(ptr);

			TUint charsInSegment= isUnicode ? ptr.Length()/2 : ptr.Length();
			LOGGSMU2("CSmsMessage::EncodeBufferL: segmenting added %d chars", charsInSegment);

			//
			// At this point the working PDU is either full (e.g. we filled the
			// remaining space with a chuck of text, or the is some space as we
			// stored the last part of the text.
			//
			// If there are any elements not yet stored, add them to the
			// formatting array...
			//
			charsAdded2CurrentPDU+=charsInSegment;
			CorrectFormattingL(charsAdded2CurrentPDU, correctedFormatingIEArray, charsAlreadyAdded);
			charsAlreadyAdded+=charsAdded2CurrentPDU;
			LOGGSMU2("CSmsMessage::EncodeBufferL(): charsAlreadyAdded=%d", charsAlreadyAdded);
			
			//
			// Now store this PDU and reset the working PDU...
			//
			aFreeUDUnitsInLastPDU = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
			AddCurrentPDUToPDUArrayL(aDoEncode);
			ResetWorkingPDUL();
			informationToSend=EFalse;
			charsAdded2CurrentPDU=0;
			
			//
			// Find the encoding method for the next segment...
			//
			//encodingToUse = ESmsEncodingNone;
			//TRAP_IGNORE(encodingToUse = segmenter->FindBestAlternativeEncodingL(iAdditionalInfo->iAlternative7bitEncoding,
			//												                    maxBodyLength));
			SmsPDU().SetNationalLanguageEncodingL(encodingToUse);

			//
			// Add any elements that can be placed now given we have a new
			// empty PDU... 
			//
			LOGGSMU3("CSmsMessage::EncodeBufferL: IE count  %d corrected  count %d",
			         iInformationElementArray->Count(), correctedFormatingIEArray.Count() );
			if ((TUint)iInformationElementArray->Count() > currEMSIEno  ||
				correctedFormatingIEArray.Count() > 0)
				{
				AddEMSInformationElementsToMultiSegmentMessageL(*segmenter, charsAdded2CurrentPDU,
																aDoEncode, encodingToUse,
																correctedFormatingIEArray,
																currEMSIEno, charsAlreadyAdded);
				}
			LOGGSMU1("CSmsMessage::EncodeBufferL end Moreloop");
			}
	CleanupStack::PopAndDestroy(buf);

	LOGGSMU1("CSmsMessage::EncodeBufferL - last PDU");
	
	//
	// This is the last PDU. We need to check if there is a partial PDU left over
	// and add it if needed.
	//
	if (informationToSend)
		{
		aFreeUDUnitsInLastPDU = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
		AddCurrentPDUToPDUArrayL(aDoEncode);
		ResetWorkingPDUL();
		}

	//
	// At this point the segmenting and layouts of PDU is complete, so if we
	// find any more data something is wrong...
	//
	if (segmenter->MoreL()  ||  correctedFormatingIEArray.Count() > 0)
		{
		User::Leave(KErrCorrupt);
		}

	CleanupStack::PopAndDestroy(3, &correctedFormatingIEArray); // segmenter, converter & correctedFormatingIEArray

	//
	// By now the PDUs are segmented and correctly setup for encoding.
	// They have not been encoded yet, as this requires the PDU total to be known.
	// So we go through the array setting the final PDU number/total PDUs and
	// perform the encoding from CSmsPDU to the TGsmPdu object.
	//
	// Note: In the case were aDoEncode is EFalse, iSmsPDUArray will be full
	//       of NULL pointers as it is only the count that we need in that case.
	//
	TInt  numPDUs = iAdditionalInfo->SmsPDUArray().Count();

	LOGGSMU2("CSmsMessage::EncodeBufferL number of PDUs: %d", iAdditionalInfo->SmsPDUArray().Count());
	
	if (aDoEncode)
		{
		CSmsMessageAdditionalAttributes::CSmsStatusReportScheme&  scheme = iAdditionalInfo->GetStatusReportScheme();
		TGsmSms  gsmSms;
		
		for (TInt pdu = 0;  pdu < numPDUs;  pdu++)
			{
			if(scheme.Id() == EControlParametersScheme)
				{
				if(smscPresent)				
					{
					CSmsSMSCCtrlParameterOperations&  ieOp = (CSmsSMSCCtrlParameterOperations&)GetOperationsForIEL(CSmsInformationElement::ESmsIEISMSCControlParameters);
					TUint8 octet(0);

					if (ieOp.GetStatusReport(pdu, octet) == KErrNone)
						{					
						iAdditionalInfo->SmsPDUArray()[pdu]->UpdateSMSCCtrlParameterL(octet);
						}
					}
				else
					{
					User::Leave(KErrNotFound);
					}
				}
			else if(scheme.Id() == ETPSRRScheme)
				{
				TSmsFirstOctet smsReportRequest;
				CSmsTPSRROperations& nonIEOp = (CSmsTPSRROperations&)GetOperationsForNonIEL(ESmsTPSRRParameter);
				smsReportRequest = nonIEOp.GetStatusReport(pdu);
								
				iAdditionalInfo->SmsPDUArray()[pdu]->UpdateTPSRRL(smsReportRequest);
				}

			if(emailPresent)				
				{
				iAdditionalInfo->SmsPDUArray()[pdu]->UpdateEmailHeaderDataL(emailOverallHeaderLength);
				}

			//
			// Set the concatenation Message Reference number and PDU numbers...
			//
			iAdditionalInfo->SmsPDUArray()[pdu]->UpdateConcatenationDataL(aReference, pdu+1, numPDUs);

			//
			// Encode this PDU...
			//
			
			TEncodeParams encodeParams;
			encodeParams.iTimeStamp = &Time();
			
			TTimeIntervalSeconds interval = UTCOffset();
			encodeParams.iTimeIntervalInSeconds = &interval;
						
			iAdditionalInfo->SmsPDUArray()[pdu]->EncodeMessagePDUL(gsmSms, &encodeParams);
	 		aSmsArray.AppendL(gsmSms);
			}

		//
		// Since the working PDU has been reset the data in it does not match
		// the data of the last PDU. Some tests in SMS Stack assume it does
		// and therefore to retain compatibility we decode the last PDU back
		// over the working PDU.
		//
		TGsmuLex8 lex(gsmSms.Pdu());
		SmsPDU().DecodeL(lex);
		}
	} // CSmsMessage::EncodeBufferL


/**
 *  Attempts to encode into the single PDU. This function is the private version
 *  to the public EncodeIntoSinglePDUL() function. It performs the work and also
 *  returns more information regarding the characters encoded.
 *  
 *  The Text and the EMS objects are laid out with respect to start position
 *  locations.
 *  
 *  @leave KErrUnderflow if the Ems objects are not in Start position order.
 *
 *  @param aSmsArray               Returned array of newly created TSms objects
 *                                 containing the encoded message.
 *  @param aUnconvertedChars       Exit param for the number of characters not converted.
 *  @param aDowngradedChars        Exit param for the number of characters downgraded.
 *  @param aFreeUDUnitsInLastPDU   Exit param for the number of characters free
 *                                 in the last PDU.
 */
TBool CSmsMessage::EncodeIntoSinglePDUL(CArrayFix<TGsmSms>& aSmsArray, TInt& aUnconvertedChars,
		                                TInt& aDowngradedChars, TInt& aFreeUDUnitsInLastPDU)
	{
	LOGGSMU1("CSmsMessage::EncodeIntoSinglePDUL()");

	__ASSERT_DEBUG((aSmsArray.Count()==0),Panic(KGsmuPanicSmsArrayNotEmpty));

	aUnconvertedChars     = 0;
	aDowngradedChars      = 0;
	aFreeUDUnitsInLastPDU = 0;

	iAdditionalInfo->SmsPDUArray().ResetAndDestroy();

	if (!TextPresent())
		{
        if(SmsPDU().Type()==CSmsPDU::ESmsCommand)
            {
            // Commands don't contain text, so commands
            // are only encoded in this branch.
            PrepareCommandMessageL();
            }

		TGsmSms sms;
		SmsPDU().EncodeMessagePDUL(sms);
		aSmsArray.AppendL(sms);
		return ETrue;
		}

	ResetWorkingPDUL();

    // find the length of all the control information elements
    TUint ieLength=0;
    for (TUint8 category = 0; category <  TSmsInformationElementCategories::ENumberOfCategories; category++)
        {
        switch (category)
            {
            case  TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly:
            case  TSmsInformationElementCategories::ECtrlSingleInstanceOnly:
            case  TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed:
                {
                for (TUint j = 0; j < iAdditionalInfo->NumberOfControlInformationElements((CSmsMessageAdditionalAttributes::TCategory) category); j++)
                    {
                    ieLength += iAdditionalInfo->GetControlInformationElementL( ( (CSmsMessageAdditionalAttributes::TCategory) category), j).Length();
                    }
                break;
                }
            default:
                break;
            }
        }
    LOGGSMU2("CSmsMessage::EncodeIntoSinglePDUL, ctrl elem len = %d", ieLength);

	CEmsInformationElement* emsIE =NULL;
	for (TInt num=0; num<iInformationElementArray->Count();num++)
		{
		emsIE = (*iInformationElementArray)[num];
        ieLength+=emsIE->Length();
		}

	TInt remainInBody=SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining(ieLength);

	TInt msgLength=MessageLengthL(); // in octets

	if( msgLength > remainInBody) return EFalse;

    LOGGSMU4("CSmsMessage::EncodeIntoSinglePDUL, ie len = %d, remainInBody = %d, msgLength = %d", ieLength, msgLength, remainInBody);
    //  add all control information elements into working PDU.
    //
    for (TUint8 category = 0; category <  TSmsInformationElementCategories::ENumberOfCategories; category++)
        {
        switch (category)
            {
            case  TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly:
            case  TSmsInformationElementCategories::ECtrlSingleInstanceOnly:
            case  TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed:
                {
                for (TUint j = 0; j < iAdditionalInfo->NumberOfControlInformationElements((CSmsMessageAdditionalAttributes::TCategory) category); j++)
                    {
                    CSmsInformationElement& informationElement = iAdditionalInfo->GetControlInformationElementL( ( (CSmsMessageAdditionalAttributes::TCategory) category), j);

                    CSmsInformationElement* cloneInformationElement = CSmsInformationElement::NewL(informationElement.Identifier(),informationElement.Data());
                    CleanupStack::PushL(cloneInformationElement);
                    TBool willFit = SmsPDU().UserData().ControlInformationElementWillFitL(cloneInformationElement);
                    CleanupStack::PopAndDestroy(cloneInformationElement);

                    if (willFit)
                        {
                        SmsPDU().UserData().UpdateInformationElementArrayL(informationElement.Identifier(),informationElement.Data());
                        }
                    else
                        {
                        ResetWorkingPDUL();
                        return EFalse;
                        }
                    }
                break;
                }
            default:
                break;
            }
        }
		
	EncodingTPSRRFromSchemesIntoSinglePDUL();

	TInt maxBodyLength=SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(*iCharacterSetConverter,iFs,SmsPDU().Alphabet(),BinaryData());
	CSmsEMSBufferSegmenter* segmenter=CSmsEMSBufferSegmenter::NewLC(*converter,*iBuffer, maxBodyLength);

	//
	// Find the best alternative encoding for the current segment. This will be
	// set at the beginning of each PDU using the list of encoders.
	//
	TSmsEncoding  encodingToUse = ESmsEncodingNone;

	TRAP_IGNORE(encodingToUse= segmenter->FindBestAlternativeEncodingL(iAdditionalInfo->Alternative7bitEncoding(),
													                   maxBodyLength));
	SmsPDU().SetNationalLanguageEncodingL(encodingToUse);
	
	if(!AddEMSInformationElementsToSingleSegmentMessageL(*segmenter, encodingToUse))
		{
		aSmsArray.Reset();
		CleanupStack::PopAndDestroy(2, converter);
		return EFalse;
		}

	if(segmenter->MoreL())
			{
			TInt size = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();
			// Defensive code to prevent SegmentNextL being called with size of zero
			if (size == 0)
				{
				CleanupStack::PopAndDestroy(2, converter);
				aSmsArray.Reset();
				return EFalse;
				}
			HBufC8* buf=HBufC8::NewMaxLC(maxBodyLength);
			TPtr8 ptr(buf->Des());
			segmenter->SegmentNextL(ptr, size, aUnconvertedChars, aDowngradedChars, encodingToUse);
			SmsPDU().UserData().AppendBodyL(ptr);
			CleanupStack::PopAndDestroy(buf);
			}
	CorrectFormattingInSinglePDUL();

	if (segmenter->MoreL())
		{
		CleanupStack::PopAndDestroy(2, converter);
		aSmsArray.Reset();
		return EFalse;
		}
	CleanupStack::PopAndDestroy(2, converter);

	aFreeUDUnitsInLastPDU = SmsPDU().UserData().MaxPackedUDUnitsInBodyRemaining();

	//
	// Encode the PDU...
	//
	TGsmSms  gsmSms;
		
	TEncodeParams encodeParams;
	encodeParams.iTimeStamp = &Time();
		
	TTimeIntervalSeconds interval = UTCOffset();
	encodeParams.iTimeIntervalInSeconds = &interval;
		
	SmsPDU().EncodeMessagePDUL(gsmSms, &encodeParams);
	aSmsArray.AppendL(gsmSms);

	return ETrue;
	} // CSmsMessage::EncodeIntoSinglePDUL


/**
 *  Attempts to encode into the single PDU
 *  The Text and the EMS objects are layed out with respect to start position locations and encoded into the correct Tsms object.
 *  Ensure this function is called before EncodeMessagePDUsL to properly process single PDU messages
 *  
 *  @return KErrUnderflow if the Ems objects are not in Start position order.
 *  @param aSmsArray returned array of newly created TSms objects containing the encoded message
 *  
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::EncodeIntoSinglePDUL(CArrayFix<TGsmSms>& aSmsArray)
	{
	LOGGSMU1("CSmsMessage::EncodeIntoSinglePDUL()");
	
	TInt  unconvertedChars, downgradedChars, freeUDUnitsInLastPDU;
	
	return EncodeIntoSinglePDUL(aSmsArray, unconvertedChars,
                                downgradedChars, freeUDUnitsInLastPDU);
	} // CSmsMessage::EncodeIntoSinglePDUL


void CSmsMessage::EncodingTPSRRFromSchemesIntoSinglePDUL()
	{
	TInt smscIndex(0);
	TBool smscPresent(EFalse);
	
	CSmsMessageAdditionalAttributes::CSmsStatusReportScheme& scheme = iAdditionalInfo->GetStatusReportScheme();	
	if(scheme.Id() == EControlParametersScheme)
		{
		if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEISMSCControlParameters,smscIndex))
			{
			smscPresent=ETrue;
			}
		if(smscPresent)				
			{
			TUint8 octet(0);

			CSmsSMSCCtrlParameterOperations& ieOp = (CSmsSMSCCtrlParameterOperations&)GetOperationsForIEL(CSmsInformationElement::ESmsIEISMSCControlParameters);
			
			if (ieOp.GetStatusReport(0, octet) == KErrNone)
				{
				if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEISMSCControlParameters,smscIndex))
					{
					SmsPDU().UserData().InformationElement(smscIndex).Data()[0] = octet;
					if (SmsPDU().Type() == CSmsPDU::ESmsSubmit)
						{
						((CSmsSubmit&)SmsPDU()).SetStatusReportRequest(ETrue);	
						}
					else if (SmsPDU().Type() == CSmsPDU::ESmsDeliver)
						{
						((CSmsDeliver&)SmsPDU()).SetStatusReportIndication(ETrue);
						}
					}
				else
					{
					User::Leave(KErrCorrupt);	
					}	
				}
			}
		else
			{
			User::Leave(KErrNotFound);
			}	
		}
	else if(scheme.Id() == ETPSRRScheme)
		{
		TSmsFirstOctet smsReportRequest;
		CSmsTPSRROperations& nonIEOp = (CSmsTPSRROperations&)GetOperationsForNonIEL(ESmsTPSRRParameter);
		smsReportRequest = nonIEOp.GetStatusReport(0);
		
		if(smsReportRequest>=0)
			{
			if (SmsPDU().Type() == CSmsPDU::ESmsSubmit)
				{
				((CSmsSubmit&)SmsPDU()).SetStatusReportRequest(smsReportRequest);	
				}
			else if (SmsPDU().Type() == CSmsPDU::ESmsDeliver)
				{
				((CSmsDeliver&)SmsPDU()).SetStatusReportIndication(smsReportRequest);
				}	
			}
		}	
	} // CSmsMessage::EncodingTPSRRFromSchemesIntoSinglePDUL


/**
 *  Decode CSmsMessage
 *  
 *  @param aUserData Object containing the EMS objects.
 *  @param aCharsAlreadyAdded The current, running, start position to be applied to the objects taken out
 *  of the UserData.
 */
void CSmsMessage::DecodeBufferL(CArrayPtr<CSmsPDU>& aSmsPDUArray,
								CSmsBufferBase& aBuffer)
	{
	LOGGSMU1("CSmsMessage::DecodeBufferL()");

	iInformationElementArray->ResetAndDestroy();

	TSmsStatusReportScheme schemeId = FindSchemeL(aSmsPDUArray);
	
	TInt emailLen(0);
	for (TInt i=0; i<aSmsPDUArray.Count(); i++)
		{
		CSmsUserData& usrData = (aSmsPDUArray)[i]->UserData();
		InstallControlInformationElementsL(usrData, i);
		InstallEmsInformationElementsL(usrData, aBuffer.Length());
        // Possible refactoring opportunity:
        // This would be a good place to add a method which provides processing for control information
        // elements which contain values specific to the pdu (as opposed to being constant in every PDU.
        InstallEmailHeaderInformationElementL(usrData,emailLen);
        if(schemeId == ETPSRRScheme)
        	{
        	InstallTPSRRInformationL(aSmsPDUArray, i);
        	}
        
		CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(*iCharacterSetConverter,iFs,aSmsPDUArray[i]->Alphabet(),BinaryData());
		TSmsBufferReassembler reassembler(*converter,aBuffer);
        TSmsEncoding  encodingUsedInSegment = aSmsPDUArray[i]->NationalLanguageEncoding();
		
        reassembler.ReassembleNextL(usrData.Body(),
									encodingUsedInSegment,
									i==(aSmsPDUArray.Count()-1));
        
		CleanupStack::PopAndDestroy(converter);		
		MergeAlternative7bitEncoding(encodingUsedInSegment);
		}

    // Possible refactoring opportunity:
    // This would be a good place to add a method which provides processing for control information
    // elements which contain values specific to the pdu (as opposed to being constant in every PDU.
    if(emailLen>0)
		{
		if(emailLen>255)
			User::Leave(KErrTooBig);
		TBuf8<1> data;
		data.SetLength(1);
		data[0]=static_cast<TUint8>(emailLen);
		TInt emailIndex;
		if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEIRFC822EmailHeader,emailIndex))
			SmsPDU().UserData().InformationElement(emailIndex).Data()[0]=static_cast<TInt8>(emailLen);
		else
			SmsPDU().UserData().AddInformationElementL(CSmsInformationElement::ESmsIEIRFC822EmailHeader,data);
		}
	UpdateUserPromptAndODIElementsStartPosition();
	} // CSmsMessage::DecodeBufferL

/**
 *  It decodes only raw text data.
 *  
 *  @param aSmsPDUArray Object containing PDUs.
 *  @param aBuffer where the decoded data will be stored.
 *
 */
void CSmsMessage::DecodeOnlyTextL(CArrayPtr<CSmsPDU>& aSmsPDUArray,
								CSmsBufferBase& aBuffer)
	{
	LOGGSMU1("CSmsMessage::DecodeOnlyTextL()");

	for (TInt i=0; i<aSmsPDUArray.Count(); i++)
		{
        CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(*iCharacterSetConverter,iFs,aSmsPDUArray[i]->Alphabet(),BinaryData());
        TSmsBufferReassembler reassembler(*converter,aBuffer);
		TSmsEncoding  encodingUsedInSegment = aSmsPDUArray[i]->NationalLanguageEncoding();
        
		reassembler.ReassembleNextL(aSmsPDUArray[i]->UserData().Body(),
									encodingUsedInSegment,
									i==(aSmsPDUArray.Count()-1));
		
		CleanupStack::PopAndDestroy(converter);
		MergeAlternative7bitEncoding(encodingUsedInSegment);
		}
	} // CSmsMessage::DecodeBufferL

/**
 *  It adds the incomplete message info in additional attribute field.
 *  
 *  @param aStartPDU starting PDU index of incomplete message.
 *  @param aEndPDU end PDU index of incomplete message.
 *  @param aLastPartialCompleteMsg boolean value indicating whether 
 				this message is the last incomplete message sent to client.
 */
void CSmsMessage::AddIncompleteMessageInfoL(TInt aStartPDU, TInt aEndPDU, TBool aLastPartialCompleteMsg)
	{
	LOGGSMU1("CSmsMessage::AddIncompleteMessageInfoL()");

	CIncompleteClass0MessageInfo& incompleteClass0MsgInfo = (CIncompleteClass0MessageInfo&) iAdditionalInfo->GetNonIEOperationL(ESmsIncompleteClass0MessageParameter);
	incompleteClass0MsgInfo.SetVersion(CIncompleteClass0MessageInfo::ESmsIncompleteClass0MessageV0);
	incompleteClass0MsgInfo.SetIncompleteMessageInfoL(aStartPDU, aEndPDU, aLastPartialCompleteMsg);
	}

/**
 *  This method copies control information elements from the user data (passed as an
 *  input argument) into either the CSmsMessage's user data (working pdu) OR one of the
 *  collection of control information elements (sorted by category) which is contained
 *  in CSmsMessage::iAdditionalInfo.
 *  
 *  @param aUserData
 *  The user data which is currently being processed, and whose elements may be copied
 *  into the appropriate collection belonging to the CSmsMessage.
 *  @leave
 *  KErrArgument if an information element's type is unknown
 *  
 *  @internalComponent
 */
void CSmsMessage::InstallControlInformationElementsL(CSmsUserData& aUserData, TInt aSegmentSequenceNum)
    {
	// Installs all the information elements within the subsequent PDUs.
	LOGGSMU1("CSmsMessage::InstallControlInformationElements()");

    CSmsMessageAdditionalAttributes::CSmsStatusReportScheme& scheme = iAdditionalInfo->GetStatusReportScheme();
    
	for (TInt z=0; z<aUserData.NumInformationElements(); z++)
		{
		const CSmsInformationElement& ie = aUserData.InformationElement(z);

         TSmsInformationElementCategories::TInformationElementCategory category;

        if (TSmsInformationElementCategories::GetCategoryDefinition(ie.Identifier(), category))
        	{
            switch (category)
                {
                case  TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUMultipleInstancesPerPDU: // e.g. Special SMS Message Indication
                    LOGGSMU2("CSmsMessage::InstallControlInformationElements \
                    ECtrlMandatoryInEveryPDUMultipleInstancesPerPDU id = %d", ie.Identifier());

                    if (ie.Identifier()== CSmsInformationElement::ESmsIEISpecialSMSMessageIndication)
                        {
                        TBool found = EFalse;
                        CArrayFixFlat<TInt>* indices = new(ELeave) CArrayFixFlat<TInt>(4);
                        CleanupStack::PushL(indices);
                        SmsPDU().UserData().InformationElementIndicesL(ie.Identifier(), *indices);

                        TInt count = indices->Count();
		                for (TInt i=0; ((i<count) && (found==EFalse)); i++)
		                    {
		                    TUint index = indices->operator[](i);
		                    CSmsInformationElement& ieAlreadyInWorkingPDU = SmsPDU().UserData().InformationElement(index);

                            if (ieAlreadyInWorkingPDU.Data()[0] == ie.Data()[0])
                                {
                                ieAlreadyInWorkingPDU.Data()[1] = ie.Data()[1];
                                found = ETrue;
                                break;
                                }
		                    }
                        CleanupStack::PopAndDestroy(indices);

                        if (found == EFalse)
                            {
                            SmsPDU().UserData().UpdateInformationElementArrayL(ie.Identifier(),ie.Data());
                            }
                        }
                    else
                        {
                        // Unknown category.
                        LOGGSMU3("CSmsMessage::InstallControlInformationElementsL category = %d, id = %d", category, ie.Identifier());
                        User::Leave(KErrArgument);
                        }
                    break;
                case  TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly:
                case  TSmsInformationElementCategories::ECtrlSingleInstanceOnly:
                    {
                    LOGGSMU2("CSmsMessage::InstallControlInformationElements ECtrlMandatoryIn1stPDUOnly "
                                 "ECtrlSingleInstanceOnly, id = %d", ie.Identifier());

                    TUint index = 0;
                    if (iAdditionalInfo->Find1stInstanceOfControlInformationElement(ie.Identifier(), index))
                        {
                        iAdditionalInfo->DeleteControlInformationElement(category, index); //  might want to pass the
                                                                                                //  id in as an additional check
                                                                                                //  this should be an exception case
                        CSmsInformationElement* newInformationElement = CSmsInformationElement::NewL(ie.Identifier(),ie.Data());

                    	CleanupStack::PushL(newInformationElement);
                    	iAdditionalInfo->AddControlInformationElementL(category, newInformationElement);
                        CleanupStack::Pop(newInformationElement);
                        }
                     else
                        {
                        CSmsInformationElement* cloneInformationElement = CSmsInformationElement::NewL(ie.Identifier(),ie.Data());
                        CleanupStack::PushL(cloneInformationElement);
                        iAdditionalInfo->AddControlInformationElementL(category, cloneInformationElement);
                        CleanupStack::Pop(cloneInformationElement);
                        }
                    break;
                    }
                case  TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUAndWithIdenticalValues:
                    {
                    LOGGSMU2("CSmsMessage::InstallControlInformationElements ECtrlMandatoryInEveryPDUAndWithIdenticalValues "
                                 "ECtrlSingleInstanceOnly, id = %d", ie.Identifier());
                    TInt index = 0;
                    if (SmsPDU().UserData().InformationElementIndex(ie.Identifier(),index))
                        {
                        CSmsInformationElement* newInformationElement = CSmsInformationElement::NewL(ie.Identifier(),ie.Data());

                    	CleanupStack::PushL(newInformationElement);
                        CSmsInformationElement*& indexedPDU = SmsPDU().UserData().InformationElementPtr(index);
                        CSmsInformationElement* oldInformationElement = indexedPDU;
                        SmsPDU().UserData().InformationElementPtr(index) = newInformationElement;
						// In next loop, oldInformationElement will point to the newly created information element. So double free is no case.
						// coverity[double_free]
                        delete oldInformationElement;
                        CleanupStack::Pop(newInformationElement);
                        }
                    else
                        {
                        SmsPDU().UserData().UpdateInformationElementArrayL(ie.Identifier(),ie.Data());
                        }
                    break;
                    }

                case  TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed:
                    {
                    LOGGSMU2("CSmsMessage::InstallControlInformationElements ECtrlMandatoryInEveryPDUAndWithIdenticalValues "
                                 "ECtrlSingleInstanceOnly, id = %d", ie.Identifier() );

                    CSmsInformationElement* cloneInformationElement = CSmsInformationElement::NewL( ie.Identifier(),ie.Data() );
                    CleanupStack::PushL(cloneInformationElement);
                    iAdditionalInfo->AddControlInformationElementL( TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed, cloneInformationElement);
                    CleanupStack::Pop(cloneInformationElement);
                    break;
                    }
                case  TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU:
                    LOGGSMU2("CSmsMessage::InstallControlInformationElements ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU "
                                 "ECtrlSingleInstanceOnly, id = %d", ie.Identifier() );
                    
                    if (ie.Identifier() == CSmsInformationElement::ESmsIEISMSCControlParameters)
                    	{
                       	if(scheme.Id() == EControlParametersScheme)
                    		{
                    		CSmsMessageAdditionalAttributes::CControlParametersScheme& ctrlParamScheme = (CSmsMessageAdditionalAttributes::CControlParametersScheme&)scheme;
                    		ctrlParamScheme.iDefaultStatusReport = 0x00;
                    		
	                       	const TUint8* octet(0);
	                    	octet = ie.Data().Ptr();
	                    	if(*octet)
                    			{
                    			CSmsMessageAdditionalAttributes::CControlParametersScheme::TSmsSMSCCtrlParameterStatus smscCtrlParameterStatus;
								smscCtrlParameterStatus.iSegmentSequenceNum = aSegmentSequenceNum;
								smscCtrlParameterStatus.iSelectiveStatus = *octet;
								(ctrlParamScheme.iControlParametersStatusReport).AppendL(smscCtrlParameterStatus);
                    			}
                    		ctrlParamScheme.iNumOfPDUs++;
	                    	}
	                    }
                
                    // e.g  Email Header / Concatenation Elements.
                    // Consider whether EMail Header should be ported here.
                    // or left as is.
                    break;
                case  TSmsInformationElementCategories::EEmsInformationElement:
                    LOGGSMU2("CSmsMessage::InstallControlInformationElements ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU "
                                 "ECtrlSingleInstanceOnly, id = %d", ie.Identifier() );
                    // Will be handled in the method InstallEmsInformationElements, nothing to do here
                    break;
                default:
                    LOGGSMU3("CSmsMessage::InstallControlInformationElementsToMultiSegmentMessageL, default switch, category = %d, id= %d", category, ie.Identifier() );
                    break;
                }
            }
    	}
    } // CSmsMessage::InstallControlInformationElementsL


/**
 *  Extracts all the EMS information objects out of the given UserData into the CSmsMessage IEArray.
 *  
 *  @param aUserData Object containing the EMS objects.
 *  @param aCharsAlreadyAdded The current, running, start position to be applied to the objects taken out
 *  of the UserData.
 */
void  CSmsMessage::InstallEmsInformationElementsL(CSmsUserData& aUserData, TInt aCharsAlreadyAdded)
	{
	// Installs all the information elements within the subsequent PDUs.
	LOGGSMU1("CSmsMessage::InstallEmsInformationElements()");

	CSmsInformationElement::TSmsInformationElementIdentifier id;
	CEmsInformationElement* newIE =NULL;

	for (TInt z=0; z<aUserData.NumInformationElements(); z++)
		{
		const CSmsInformationElement& ie = aUserData.InformationElement(z);

		// is the ie an EMS information Element;
		id = ie.Identifier();
		if (CEmsFactory::Supported(id))
			{
			newIE=NULL;
			TRAPD(ret,newIE = CEmsFactory::CreateReceivedEmsIEL(ie,aCharsAlreadyAdded));
			if(newIE != NULL)
				{
				if(ret == KErrNone)
					{
					ret=AddReceivedEmsInformationElement(newIE);
					if(ret==KErrNone)  // Remove the Information Element from the User Data.
						aUserData.RemoveInformationElement(z--);
					else
						// newIE is made NULL in first place and then a new IE is created. so double free is no case
						// coverity[double_free]
						delete newIE;
					}
				else
					delete newIE;
				}
			}
		}
	} // CSmsMessage::InstallEmsInformationElementsL


/**
 *  Extracts all the EMS information objects out of the given Command into the CSmsMessage IEArray.
 *  
 *  @param aCommand Object containing the EMS objects.
 *  @param aCharsAlreadyAdded The current, running, start position to be applied to the objects taken out
 *  of the UserData.
 */
void  CSmsMessage::InstallEmsInformationElementsL(CSmsCommand& aCommand, TInt aCharsAlreadyAdded)
    {
    // Ignore in code coverage - not used in SMS stack and not exported
    // but cannot be removed as impacts public header.
    BULLSEYE_OFF    
    // Installs all the information elements within the subsequent PDUs.
    LOGGSMU1("CSmsMessage::InstallEmsInformationElements()");
    
    CSmsInformationElement::TSmsInformationElementIdentifier id;
    CEmsInformationElement* newIE=NULL;
    
    for (TInt z=0; z<aCommand.NumInformationElements(); z++)
        {
        const CSmsInformationElement& ie = aCommand.InformationElement(z);
        // is the ie an EMS information Element;
        id = ie.Identifier();
        if (CEmsFactory::Supported(id))
            {
            newIE=NULL;
            TRAPD(ret,newIE = CEmsFactory::CreateReceivedEmsIEL(ie,aCharsAlreadyAdded));
            if(newIE != NULL )
                {
                    if(ret == KErrNone)
                    {
                        ret=AddReceivedEmsInformationElement(newIE);
                        if(ret==KErrNone)  // Remove the Information Element from the User Data.
                            aCommand.RemoveInformationElement(z--);
                        else
                            // newIE is made NULL in first place and then a new IE is created. so double free is no case.
                            // coverity[double_free]
                            delete newIE;
                    }
                    else
                        delete newIE;
                }
            }
        }
    BULLSEYE_RESTORE
    }

TSmsStatusReportScheme CSmsMessage::FindSchemeL(const CArrayPtr<CSmsPDU>& aSmsPDUArray)
	{
	TInt smscIndex(0);
	
	if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEISMSCControlParameters,smscIndex))
		{
		iAdditionalInfo->SetStatusReportSchemeL(EControlParametersScheme);
		return EControlParametersScheme;
		}
		
	TSmsFirstOctet oldTpsrr;
	TSmsFirstOctet tpsrr;
	CSmsSubmit* smsSubmit;
	CSmsDeliver* smsDeliver;
	
	if (SmsPDU().Type() == CSmsPDU::ESmsSubmit)
		{
		smsSubmit = reinterpret_cast<CSmsSubmit*>((aSmsPDUArray)[0]);
		oldTpsrr = smsSubmit->StatusReportRequest();
		}
	else if (SmsPDU().Type() == CSmsPDU::ESmsDeliver)
		{
		smsDeliver = reinterpret_cast<CSmsDeliver*>((aSmsPDUArray)[0]);
		oldTpsrr = smsDeliver->StatusReportIndication();
		}
		
	for (TInt ii=1; ii<aSmsPDUArray.Count(); ii++)
		{
		if (SmsPDU().Type() == CSmsPDU::ESmsSubmit)
			{
			smsSubmit = reinterpret_cast<CSmsSubmit*>((aSmsPDUArray)[ii]);
			tpsrr = smsSubmit->StatusReportRequest();
			}
		else if (SmsPDU().Type() == CSmsPDU::ESmsDeliver)
			{
			smsDeliver = reinterpret_cast<CSmsDeliver*>((aSmsPDUArray)[ii]);
			tpsrr = smsDeliver->StatusReportIndication();
			}
		if(tpsrr != oldTpsrr)
			{
			iAdditionalInfo->SetStatusReportSchemeL(ETPSRRScheme);
			return ETPSRRScheme;
			}
		}
	
	iAdditionalInfo->SetStatusReportSchemeL(EDefaultScheme);

	return EDefaultScheme;
	} // CSmsMessage::FindSchemeL

	
void CSmsMessage::InstallTPSRRInformationL(const CArrayPtr<CSmsPDU>& aSmsPDUArray, TInt aSegmentSequenceNum)
	{
    CSmsMessageAdditionalAttributes::CSmsStatusReportScheme& scheme = iAdditionalInfo->GetStatusReportScheme();
    CSmsMessageAdditionalAttributes::CTPSRRScheme& tpsrrScheme = (CSmsMessageAdditionalAttributes::CTPSRRScheme&)scheme;
    
    tpsrrScheme.iDefaultStatusReport = TSmsFirstOctet::ESmsStatusReportNotRequested;
    tpsrrScheme.iNumOfPDUs++;
    
    TSmsFirstOctet tpsrr;
    
    if (SmsPDU().Type() == CSmsPDU::ESmsSubmit)
		{
		CSmsSubmit* smsSubmit = reinterpret_cast<CSmsSubmit*>((aSmsPDUArray)[aSegmentSequenceNum]);
		tpsrr = smsSubmit->StatusReportRequest();
		}
	else if (SmsPDU().Type() == CSmsPDU::ESmsDeliver)
		{
		CSmsDeliver* smsDeliver = reinterpret_cast<CSmsDeliver*>((aSmsPDUArray)[aSegmentSequenceNum]);
		tpsrr = smsDeliver->StatusReportIndication();
		}
    
    if(tpsrr)
    	{
    	CSmsMessageAdditionalAttributes::CTPSRRScheme::TSmsTPSRRStatus tpsrrStatus;

    	tpsrrStatus.iSegmentSequenceNum = aSegmentSequenceNum;
		tpsrrStatus.iTPSRRStatus = TSmsFirstOctet::ESmsStatusReportRequested;
		tpsrrScheme.iTPSRRStatusReport.AppendL(tpsrrStatus);	
    	}
	} // CSmsMessage::InstallTPSRRInformationL


/**
 *  Adds EMS IE to a CSmsMessage
 *  
 *  @param aEmsIE EMS object to be added.
 *  
 *  @capability None
 */
EXPORT_C void CSmsMessage::AddEMSInformationElementL(const CEmsInformationElement& aEmsIE)
	{
	LOGGSMU1("CSmsMessage::AddEMSInformationElementL()");

	if(aEmsIE.StartPosition() > (TUint)iBuffer->Length())
		{
		User::Leave(KErrOverflow);
		}

	if(CSmsInformationElement::ESmsEnhancedTextFormatting == aEmsIE.Identifier() && aEmsIE.Length() ==0)
		{
		User::Leave(KErrUnderflow);
		}

	if(CSmsInformationElement::ESmsEnhancedUserPromptIndicator == aEmsIE.Identifier())
		{
		AddEmsUserPromptL(static_cast<const CEmsUserPrompt&>(aEmsIE));
		}
	else if(CSmsInformationElement::ESmsEnhancedODI == aEmsIE.Identifier())
		{
		AddEmsObjectDistributionL(static_cast<const CEmsObjectDistribution&>(aEmsIE));
		}
	else
		{
		TInt count=iInformationElementArray->Count();
		TInt currNo=0;
		const CEmsInformationElement* emsIE=NULL;

		while(currNo < count)
		{
			emsIE=(*iInformationElementArray)[currNo];
			if(emsIE->StartPosition() == aEmsIE.StartPosition() && (CSmsInformationElement::ESmsEnhancedUserPromptIndicator == emsIE->Identifier() || CSmsInformationElement::ESmsEnhancedODI == emsIE->Identifier()))
				User::Leave(KErrArgument);
			else if(emsIE->StartPosition() > aEmsIE.StartPosition())
				break;
			currNo++;
		}
		User::LeaveIfError(iInformationElementArray->Insert(aEmsIE.DuplicateL(),currNo));
		}
	} // CSmsMessage::AddEMSInformationElementL


TBool CSmsMessage::CanBeRemoved(const CEmsInformationElement& aIE, const TUint aIEIndex)
	{
	LOGGSMU1("CSmsMessage::CanBeRemoved()");

	TBool ret=ETrue;
	if(CSmsInformationElement::ESmsEnhancedODI == aIE.Identifier())
		return ret;

	TUint ieStartPosition=aIE.StartPosition();
	TUint count=iInformationElementArray->Count();
	CEmsInformationElement* ie=NULL;

	// is there a UserPrompt/ODI at the same position
	for (TUint i=0; i < count && ret; ++i)
		{
		ie = (*iInformationElementArray)[i];
		// Do not allow removal if start position matches a user prompt and it is not the user prompt itself being removed
		if (ie->StartPosition() == ieStartPosition && ie->Identifier() == CSmsInformationElement::ESmsEnhancedUserPromptIndicator && aIE.Identifier() != CSmsInformationElement::ESmsEnhancedUserPromptIndicator)
		    ret=EFalse;
		if (ie->Identifier() == CSmsInformationElement::ESmsEnhancedODI)
		    {
		    // don't allow removal of IE if position inside object count of ODI
		    if ((static_cast<CEmsObjectDistribution*>(ie)->ObjectCount()+i) >= aIEIndex || static_cast<CEmsObjectDistribution*>(ie)->ObjectCount() == 0)
		        ret=EFalse;
		    }
		}

	LOGGSMU2("CSmsMessage::CanBeRemoved() returns %d", ret);

	return ret;
	} // CSmsMessage::CanBeRemoved


/**
 *  Adds EMS IE to a CSmsMessage
 *  
 *  @param aEmsIE EMS object to be added.
 */
void CSmsMessage::AddEmsUserPromptL(const CEmsUserPrompt& aUserPromptIE)
	{
	LOGGSMU1("CSmsMessage::AddEmsUserPromptL()");

		if(aUserPromptIE.ObjectCount() == 0 )User::Leave(KErrArgument);

		TUint count=iInformationElementArray->Count();
		TUint userPromptStartPosition=aUserPromptIE.StartPosition();

		TSmsId id=aUserPromptIE.Identifier();
		TBool allSameType=ETrue;
		TUint countOnTheSamePos=0;
		TUint firstIndex=0;

		// collect all IEs on the same startPosition as the new User Prompt
		CEmsInformationElement* ie=NULL;

		for (TUint i=0; i < count ; i++)
		{
			ie = (*iInformationElementArray)[i];
			if (ie->StartPosition() == userPromptStartPosition)
			{
				if(countOnTheSamePos==0)
				{
					firstIndex=i;
					id = ie->Identifier();
				}
				else
				{
					if(allSameType && id != ie->Identifier())allSameType=EFalse;
					else id = ie->Identifier();
				}
				++countOnTheSamePos;
			}
		}

		if(countOnTheSamePos != aUserPromptIE.ObjectCount())
			User::Leave(KErrArgument);


	if( countOnTheSamePos == 1)
	{
		switch(id)
		{
		case CEmsInformationElement::ESmsEnhancedPredefinedAnimation:
		case CEmsInformationElement::ESmsEnhancedLargeAnimation :
		case CEmsInformationElement::ESmsEnhancedSmallAnimation	:
		case CEmsInformationElement::ESmsEnhancedUserDefinedSound:
		case CEmsInformationElement::ESmsEnhancedLargePicture:
		case CEmsInformationElement::ESmsEnhancedSmallPicture:
		case CEmsInformationElement::ESmsEnhancedVariablePicture:
		User::LeaveIfError(iInformationElementArray->Insert(aUserPromptIE.DuplicateL(),firstIndex));
			break;
		default:
		User::Leave(KErrCorrupt);
			break;
		}
		return;
	}

	// stitching - more than one object
	if(allSameType  && (id == CEmsInformationElement::ESmsEnhancedUserDefinedSound || id == CEmsInformationElement::ESmsEnhancedLargePicture || id == CEmsInformationElement::ESmsEnhancedSmallPicture || id == CEmsInformationElement::ESmsEnhancedVariablePicture))
		{
		User::LeaveIfError(iInformationElementArray->Insert(aUserPromptIE.DuplicateL(),firstIndex));
		return;
		}

    //  not of the same type or not supported IE types
	User::Leave(KErrCorrupt);
	} // CSmsMessage::AddEmsUserPromptL


/**
 *  Adds EMS IE to a CSmsMessage
 *  
 *  @param aEmsIE EMS object to be added.
 */
void CSmsMessage::AddEmsObjectDistributionL(const CEmsObjectDistribution& aObjectDistributionIE)
    {
	LOGGSMU1("CSmsMessage::AddEmsObjectDistributionL()");

    TUint count=iInformationElementArray->Count();
    TUint objectDistributionStartPosition=aObjectDistributionIE.StartPosition();

    TBool firstIndexFound=EFalse;
    TUint firstIndex=0;
    TUint countOnSameOrSubsequentPos=0;

    // collect any IEs on the same or greater startPosition as the new Object Distribution Indicator
    CEmsInformationElement* ie=NULL;

    for (TUint i=0; i < count; i++)
        {
        ie = (*iInformationElementArray)[i];
        if (ie->StartPosition() >= objectDistributionStartPosition)
            {
            // Only set index if at least one IE found at desired start position
            if (!firstIndexFound)
                {
                firstIndex=i;
                firstIndexFound=ETrue;
                }
            ++countOnSameOrSubsequentPos;
            }
        }
    // check number of IEs present for desired ObjectCount
    if(countOnSameOrSubsequentPos < aObjectDistributionIE.ObjectCount())
        User::Leave(KErrArgument);

    if (firstIndexFound)
        {
        User::LeaveIfError(iInformationElementArray->Insert(aObjectDistributionIE.DuplicateL(),firstIndex));
        return;
        }

    //  no valid IE for ODI to apply to
    User::Leave(KErrCorrupt);
    } // CSmsMessage::AddEmsObjectDistributionL


/**
 *  Removes first EMS IE that matches the criteria from the CSmsMessage
 *  
 *  @param aStartPosition of a EMS object to be removed.
 *  @param aEmsId type of a EMS object to be removed
 *  @return pointer EMS information element
 *  @capability
 *  @capability None
 */
EXPORT_C CEmsInformationElement* CSmsMessage::RemoveEMSInformationElementL(const TUint aStartPosition,const TSmsId aEmsId)
	{
	LOGGSMU1("CSmsMessage::RemoveEMSInformationElementL()");

	CEmsInformationElement* emsIE=NULL;
	CEmsInformationElement* ie=NULL;

	TUint count=iInformationElementArray->Count();

	for (TInt i=--count; i >=0 ; --i)
		{
		ie = (*iInformationElementArray)[i];
		if (ie->StartPosition() == aStartPosition && ie->Identifier() == aEmsId)
			{
				if(CanBeRemoved(*ie, i))
				{
					iInformationElementArray->Remove(i);
					emsIE=ie;
				}
				else
					emsIE=NULL;
				break;
			}

		}
	return emsIE;
	} // CSmsMessage::RemoveEMSInformationElementL


/**
 *  Removes all EMS IEs that matches the criteria from the CSmsMessage
 *  
 *  @param aStartPosition of a EMS object to be removed.
 *  @param aEmsId type of a EMS object to be removed
 *  @return pointer to array of EMS IE
 *  
 *  @capability None
 */
EXPORT_C RPointerArray<CEmsInformationElement>* CSmsMessage::RemoveEMSInformationElementsL(const TUint aStartPosition,const TSmsId aEmsId)
	{
	LOGGSMU1("CSmsMessage::RemoveEMSInformationElementsL()");

	CEmsInformationElement* ie=NULL;
	RPointerArray<CEmsInformationElement>* selectedIEs = NULL;
	TUint count=iInformationElementArray->Count();

	for (TInt i=--count; i >= 0 ; --i)
		{
		ie = (*iInformationElementArray)[i];
		if (ie->StartPosition() == aStartPosition && ie->Identifier() == aEmsId)
			{
				if(CanBeRemoved(*ie, i))
				{
					if(selectedIEs == NULL)selectedIEs=new (ELeave) RPointerArray<CEmsInformationElement>(8);
					iInformationElementArray->Remove(i);
					selectedIEs->Append(ie);
				}
			}

		}
	return selectedIEs;
	} // CSmsMessage::RemoveEMSInformationElementsL

/**
 *  Resets EMS IE from a CSmsMessage
 *  
 *  
 *  @capability None
 */
EXPORT_C void  CSmsMessage::ResetEMSL()
	{
	LOGGSMU1("CSmsMessage::ResetEMSL()");

	iInformationElementArray->ResetAndDestroy();
	} // CSmsMessage::ResetEMSL

/**
 *  Removes EMS IE from a CSmsMessage
 *  
 *  @return CArrayPtrFlat<const CEmsInformationElement>& of internal EMS array
 *  
 *  @capability None
 */
EXPORT_C const RPointerArray<const CEmsInformationElement>& CSmsMessage::GetEMSInformationElementsL()const
	{
	LOGGSMU1("CSmsMessage::GetEMSInformationElementsL()");

	 return (const RPointerArray<const CEmsInformationElement>&)(*iInformationElementArray);
	} // CSmsMessage::GetEMSInformationElementsL


void CSmsMessage::UpdateUserPromptAndODIElementsStartPosition()
	{
	LOGGSMU1("CSmsMessage::UpdateUserPromptAndODIElementsStartPosition()");

		TUint num=iInformationElementArray->Count();
		TInt startPosition=-1;
		CEmsInformationElement* ie = NULL;


		// is the ie an EMS information Element;

		for(TInt i=num-1;i >=0; --i)
		{
			ie = (*iInformationElementArray)[i];
			if(ie->Identifier() == CSmsInformationElement::ESmsEnhancedUserPromptIndicator || ie->Identifier() == CSmsInformationElement::ESmsEnhancedODI)
			{
				if(startPosition >=0)
					ie->SetStartPosition(startPosition);
				else
					iInformationElementArray->Remove(i);
			}
			else
				startPosition=ie->StartPosition();

		}
	} // CSmsMessage::UpdateUserPromptAndODIElementsStartPosition


TInt CSmsMessage::AddReceivedEmsInformationElement(CEmsInformationElement* aEmsIE)
	{
	LOGGSMU1("CSmsMessage::AddReceivedEmsInformationElement()");

	TInt ret=KErrNone;
	if(CSmsInformationElement::ESmsEnhancedUserPromptIndicator == aEmsIE->Identifier() || CSmsInformationElement::ESmsEnhancedODI == aEmsIE->Identifier())
		ret=iInformationElementArray->Append(aEmsIE);
	else
		{
			TInt count=iInformationElementArray->Count();
			TInt currNo=0;
			const CEmsInformationElement* emsIE=NULL;
			while(currNo < count)
			{
				emsIE=(*iInformationElementArray)[currNo];
				if(emsIE->StartPosition() > aEmsIE->StartPosition() && (CSmsInformationElement::ESmsEnhancedUserPromptIndicator != emsIE->Identifier() || CSmsInformationElement::ESmsEnhancedODI != emsIE->Identifier()))
					break;
				currNo++;
			}
			ret=iInformationElementArray->Insert(aEmsIE,currNo);
		}
	return ret;
	} // CSmsMessage::AddReceivedEmsInformationElement


/**
 *  Updates the slot information for the given message as described in the supplied buffer
 *  
 *  @param aDesc buffer, layout: byte 0 store id, byte 1..n PDU slot indexes
 *  @leave KErrArgument
 *  
 *  @capability None
 */
EXPORT_C void CSmsMessage::UpdateSlotsL(TDesC8& aDesc)
    {
	LOGGSMU1("CSmsMessage::UpdateSlotsL()");

    TGsmSmsSlotEntry newSlot;

    switch (aDesc[0])
        {
        case CSmsMessage::ESmsSIMStorage:
            {
            newSlot.iStore = KETelIccSmsStore;
            break;
            }
        case CSmsMessage::ESmsPhoneStorage:
            {
            newSlot.iStore = KETelMeSmsStore;
            break;
            }
        case CSmsMessage::ESmsCombinedStorage:
            {
            newSlot.iStore = KETelCombinedSmsStore;
            break;
            }
        default:
            User::Leave(KErrArgument);
        }

    for (TInt index = 1; index < aDesc.Size(); index++)
        {
        newSlot.iIndex = aDesc[index]; // point to PDU indexes
        iSlotArray.AppendL(newSlot);
        }
    } // CSmsMessage::UpdateSlotsL

/**
 *  Copy EMS elements to dest CSmsMessage
 *  Uses CSmsMessage extended EMS API
 *  Creates new CEmsInformationElement instance(s) and passes ownership to the dest CSmsMessage
 *  
 *  @return aToMessage  - Destination CSmsMessage
 *  
 *  @capability None
 */
EXPORT_C void CSmsMessage::CopyEmsElementsL(CSmsMessage& aToMessage) const
	{
	LOGGSMU1("CSmsMessage::CopyEmsElementsL()");

	// CSmsMessage extended EMS API method creates array of references to EMS elements in
	// the source message
	// Loop through the array copying each individual method using the CSmsMessage
	// and CEmsInformationElement API's
	CEmsInformationElement* dupl=NULL;
	aToMessage.ResetEMSL();
	for(TInt i = iInformationElementArray->Count()-1 ; i >=0; --i)
		{
		dupl = (*iInformationElementArray)[i]->DuplicateL();
		CleanupStack::PushL(dupl);
		aToMessage.AddEMSInformationElementL(*dupl);
		CleanupStack::PopAndDestroy(dupl);
		}
	} // CSmsMessage::CopyEmsElementsL

/**
 *  @capability None
 */
EXPORT_C void CSmsMessage::AddSlotL(const TGsmSmsSlotEntry& aSlot)
	{
	LOGGSMU1("CSmsMessage::AddSlotL()");

		TInt count = iSlotArray.Count();
		TInt i(0);
		TBool found(EFalse);
		while(!found && i<count)
		{
			if(aSlot.iIndex == iSlotArray[i].iIndex)found=ETrue;
			else ++i;
		}
		LOGGSMU3("CSmsMessage::AddSlotL current no in: %d, adds index %d", count,aSlot.iIndex );
		LOGGSMU3("found %d at position %d",found,i);
		iSlotArray.AppendL(aSlot);
	} // CSmsMessage::AddSlotL

/**
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::MatchSlots(const CArrayFixFlat<TGsmSmsSlotEntry>& aSlotArray)
	{
	LOGGSMU1("CSmsMessage::MatchSlots()");

		TBool match = EFalse;
		TInt count = aSlotArray.Count();
		if(iSlotArray.Count() == count)
		{
			TInt i = 0;
			match = ETrue;
			while(match && i < count)
				{
				const TGsmSmsSlotEntry& newSlot=aSlotArray[i];
				const TGsmSmsSlotEntry& slot =iSlotArray[i];
				if ( ( slot.iIndex != newSlot.iIndex ) || ( slot.iStore != newSlot.iStore ) )
						match = EFalse;
				i++;
				}

		}
		return match;
	} // CSmsMessage::MatchSlots

/**
 *  c'tor
 *  @capability None
 */
EXPORT_C TGsmSmsSlotEntry::TGsmSmsSlotEntry()
	{
	} // TGsmSmsSlotEntry::TGsmSmsSlotEntry

/**
 *  Internalize
 *  
 *  @param aStream For internalizing the data
 */
void TGsmSmsSlotEntry::InternalizeL(RReadStream& aStream)
	{
	aStream >> iStore;
	iIndex=aStream.ReadInt32L();
	} // TGsmSmsSlotEntry::InternalizeL

/**
 *  Externalize
 *  
 *  @param aStream For Externalizing the data
 */
void TGsmSmsSlotEntry::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << iStore;
	aStream.WriteInt32L(iIndex);
	} // TGsmSmsSlotEntry::ExternalizeL

 /**
  *  Extracts all RFC 822 Email header information objects out of the given UserData into the CSmsMessage's iSmsEmailHeaderLength.
  *  
  *  @param aUserData Object containing the EmailHeader information element.
  *  @param aCharsAlreadyAdded The current, running, start position to be applied to the objects taken out
  *  of the UserData.
  */
void  CSmsMessage::InstallEmailHeaderInformationElementL(CSmsUserData& aUserData,TInt& aHeaderLength)
 	{
 	// Installs all the information elements within the subsequent PDUs.
 	LOGGSMU1("CSmsMessage::InstallEmailHeaderInformationElementL()");

 	CSmsInformationElement::TSmsInformationElementIdentifier id;

 	for (TInt z=0; z<aUserData.NumInformationElements(); z++)
 		{
 		const CSmsInformationElement& ie = aUserData.InformationElement(z);
 		id = (CSmsInformationElement::TSmsInformationElementIdentifier)ie.Identifier();
 		if (id == CSmsInformationElement::ESmsIEIRFC822EmailHeader)
 			{
 				const TDesC8& des = ie.Data();
 				aHeaderLength+=des[0];
 			}
 		}
 	} // CSmsMessage::InstallEmailHeaderInformationElementL

/**
 *  Extracts all RFC 822 Email header information objects out of the given UserData into the CSmsMessage's iSmsEmailHeaderLength.
 *  
 *  @param aCommand Object containing the EmailHeader information element.
 *  @param aCharsAlreadyAdded The current, running, start position to be applied to the objects taken out
 *  of the UserData.
 */
void CSmsMessage::InstallEmailHeaderInformationElementL(CSmsCommand& aCommand,TInt& aHeaderLength)
    {
    // Ignore in code coverage - not used in SMS stack and not exported
    // but cannot be removed as impacts public header.
    BULLSEYE_OFF    
    // Installs all the information elements within the subsequent PDUs.
    LOGGSMU1("CSmsMessage::InstallEmailHeaderInformationElementL()");
    
    CSmsInformationElement::TSmsInformationElementIdentifier id;
    
    for (TInt z=0; z<aCommand.NumInformationElements(); z++)
        {
        const CSmsInformationElement& ie = aCommand.InformationElement(z);
        id = (CSmsInformationElement::TSmsInformationElementIdentifier)ie.Identifier();
        if (id == CSmsInformationElement::ESmsIEIRFC822EmailHeader)
            {
            const TDesC8& des = ie.Data();
            aHeaderLength+=des[0];
            }
        }
    BULLSEYE_RESTORE
    }

// E-mail header methods

/**
 *  Adds a header to an email body
 *  
 *  @param aEMailBody The buffer to which the header gets appended
 *  @param aEmailHeader The buffer which holds RFC 822 e-mail header
 *  @publishedAll
 *  @released
 *  
 *  @capability None
 */
EXPORT_C void CSmsMessage::AddEmailHeaderL(const TDesC& aEmailHeader, const TDesC& aEmailBody)
 	{
 	LOGGSMU1("CSmsMessage::AddEmailHeaderL()");

 	if(IsEmailHeader())
 		User::Leave(KErrAlreadyExists);

 	TInt len =aEmailHeader.Length();
 	if(len <= 0)
 		User::Leave(KErrCorrupt);

	if(len >= 255 )
 		User::Leave(KErrTooBig);


	if(SmsPDU().UserData().NumInformationElements())
		{
		TBool is16bit = EFalse;
		TBool concatenationIEPresent= SmsPDU().TextConcatenated( &is16bit );
		if(concatenationIEPresent)
			{
			if(SmsPDU().UserData().NumInformationElements() >=2) // something more than concat IE
				User::Leave(KErrAccessDenied);
			}
		else
			User::Leave(KErrAccessDenied);
		}


	TBuf8<1> data;
	data.SetLength(1);
	data[0]=static_cast<TUint8>(len);
	SmsPDU().UserData().AddInformationElementL(CSmsInformationElement::ESmsIEIRFC822EmailHeader,data);

 	iBuffer->Reset();
 	iBuffer->InsertL(0,aEmailHeader);
 	iBuffer->InsertL(iBuffer->Length(),aEmailBody);
 	} // CSmsMessage::AddEmailHeaderL

 /**
  *  Checks whether the SmsMessage contains an e-mail.
  *  
  *  @return ETrue if CSmsMessage contains e-mail ( e-mail header information element), otherwise EFalse
  *  @publishedAll
  *  @released
  *  
  *  @capability None
  */
EXPORT_C TBool CSmsMessage::IsEmailHeader() const
 	{
 	LOGGSMU1("CSmsMessage::IsEmailHeader()");

	TInt emailIndex;
	return SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEIRFC822EmailHeader,emailIndex);
 	} // CSmsMessage::IsEmailHeader

 /**
  *  Extracts e-mail header and body from the SmsMessage
  *  
  *  @return aEMailHeader The buffer containing the extracted email header
  *  @return aEMailBody The buffer containing the extracted email body
  *  @return ETrue if extraction of e-mail header and body succeeds
  *  @publishedAll
  *  @released
  *  
  *  @capability None
  */
EXPORT_C TBool CSmsMessage::GetEmailHeaderL(HBufC** aEmailHeader,HBufC** aEmailBody)
 	{
 	LOGGSMU1("CSmsMessage::GetEmailHeaderL()");

 	if(IsEmailHeader())
 		{
 			TInt bufLen=iBuffer->Length();
 			TInt emailHeaderLen(0);
			TInt emailIndex(0);
			if(SmsPDU().UserData().InformationElementIndex(CSmsInformationElement::ESmsIEIRFC822EmailHeader,emailIndex))
				emailHeaderLen=SmsPDU().UserData().InformationElement(emailIndex).Data()[0];
			else
				User::Leave(KErrCorrupt);

 			TInt emailBodyLen=bufLen-emailHeaderLen;

 			if(emailBodyLen<0)
 				return EFalse;

 			*aEmailHeader=HBufC::NewL(emailHeaderLen);
 			CleanupStack::PushL(*aEmailHeader);

 			*aEmailBody=HBufC::NewL(emailBodyLen);
 			CleanupStack::PushL(*aEmailBody);

 			TPtr headerPtr((*aEmailHeader)->Des());
 			iBuffer->Extract(headerPtr,0,emailHeaderLen);

 			TPtr bodyPtr((*aEmailBody)->Des());
 			iBuffer->Extract(bodyPtr,emailHeaderLen,emailBodyLen);

 			CleanupStack::Pop(2);
 			return ETrue;
 		}
 	return EFalse;
 	} // CSmsMessage::GetEmailHeaderL


 /**
  *  Extracts the offset between universal time and local time in seconds.
  *  If the value is > 0, local time is ahead of universal time.
  *  If the value is < 0, local time is behind universal time.
  *  
  *  @return TTTimeIntervalSeconds The time zone offset in seconds.
  *  @publishedAll
  *  @capability None
  */
EXPORT_C TTimeIntervalSeconds CSmsMessage::UTCOffset() const
    {
    LOGGSMU1("CSmsMessage::UTCOffset()");

    TUint timeZoneOffset = ((iFlags & ESmsUTCOffsetSecondGranularityMask) >> ESecondBitOffset);

    if (iFlags & ESmsUTCOffsetSignBit)
        {
        timeZoneOffset = -timeZoneOffset;
        }

    return (TTimeIntervalSeconds(timeZoneOffset));
    } // CSmsMessage::UTCOffset


 /**
  *  Sets the offset between universal time and local time in seconds.
  *  If the value is > 0, local time is ahead of universal time.
  *  If the value is < 0, local time is behind universal time.
  *  The CSmsMessage Time Zone Offset has the range +/- 71100 seconds. This is same range as
  *  the Service Centre Time Stamp Time Zone Offset as specified in 23.040 V4.4.0 Sect 9.2.3.11.
  *  
  *  @return True if input value was set successfully (in range), False otherwise
  *  @publishedAll
  *  @capability None
  */
EXPORT_C TBool CSmsMessage::SetUTCOffset(const TTimeIntervalSeconds& aTimeOffset)
    {
    LOGGSMU1("CSmsMessage::SetUTCOffset()");

    TBool rc = ETrue;

    TInt timeOffset = aTimeOffset.Int();

    if ((timeOffset <=  EMaximumSeconds) &&
        (timeOffset >= -EMaximumSeconds))
        {
        // Clear the timezone offset bits
        iFlags &= (~(ESmsUTCOffsetSecondGranularityMask   |
                     ESmsUTCOffsetSignBit));

        if (timeOffset < 0)
            {
            iFlags |= ESmsUTCOffsetSignBit;
            timeOffset = -timeOffset;
            }

        iFlags |= (timeOffset << ESecondBitOffset);
        }
    else
        {
        LOGGSMU2("CSmsMessage::SetUTCOffset offset [out of range] = %d",timeOffset);
        rc = EFalse;
        }

    return rc;
} // CSmsMessage::SetUTCOffset


/**
 *  Returns the message version number.
 *  @capability
 */
EXPORT_C TInt CSmsMessage::Version()
 	{
 	LOGGSMU1("CSmsMessage::Version()");

 	return iVersion;
 	} // CSmsMessage::Version


/**
 *  @internalComponent
 *  Validates and sets the message version number.
 *  
 *  @param aVersion version number to set.
 *  @return KErrNone if aVersion is valid and successfully set, KErrArgument otherwise.
 *  @capability None
 */
EXPORT_C TInt CSmsMessage::SetVersion(TInt aVersion)
	{
 	LOGGSMU2("CSmsMessage::SetVersion()", aVersion);

	if((aVersion>=ESmsMessageV0) && (aVersion<=ESmsMessageV4))
		{
		iVersion=aVersion;
		return KErrNone;
		}

	return KErrArgument;
	} // CSmsMessage::SetVersion


/**
 *  @internalComponent
 *  Internalises all object data except for the CSmsBufferBase and the message version.
 *  
 *  This is used when the buffer is stored elsewhere.
 *  
 *  @param aStream Stream to read from
 *  @capability None
 */
EXPORT_C void CSmsMessage::InternalizeWithoutBufferAndVersionL(RReadStream& aStream)
	{
 	LOGGSMU1("CSmsMessage::InternalizeWithoutBufferAndVersionL()");

	iFlags=aStream.ReadInt32L();
	iStatus=(NMobileSmsStore::TMobileSmsStoreStatus) aStream.ReadInt32L();
	iLogServerId=aStream.ReadInt32L();
	TInt64 time;
	aStream >> time;
	iTime=time;

	CSmsPDU* smspdu=CSmsPDU::NewL(aStream,*iCharacterSetConverter,iFs);
	delete iSmsPDU;
	iSmsPDU=smspdu;
	iIs16BitConcatenation=aStream.ReadInt32L();

	iInformationElementArray->ResetAndDestroy();
	CEmsFactory::InternalizeL(*iInformationElementArray, aStream);

	TInt count=aStream.ReadInt32L();
	iSlotArray.Reset();
	TInt i=0;
	TGsmSmsSlotEntry newSlot;
	for (; i<count; i++)
		{
		newSlot.InternalizeL(aStream);
		AddSlotL(newSlot);
		}
	} // CSmsMessage::InternalizeWithoutBufferAndVersionL


/**
 *  @internalComponent
 *  Externalises all object data except for the CSmsBufferBase and the message version.
 *  
 *  This is used when the buffer is stored elsewhere.
 *  
 *  @param aStream Stream to write to
 *  @capability None
 */
EXPORT_C void CSmsMessage::ExternalizeWithoutBufferAndVersionL(RWriteStream& aStream) const
	{
 	LOGGSMU1("CSmsMessage::ExternalizeWithoutBufferAndVersionL()");

	aStream.WriteInt32L(iFlags);
	aStream.WriteInt32L(iStatus);
	aStream.WriteInt32L(iLogServerId);
	aStream << Time().Int64();

	SmsPDU().ExternalizeL(aStream);
	aStream.WriteInt32L(iIs16BitConcatenation);

	CEmsFactory::ExternalizeL(*iInformationElementArray, aStream);
	TInt count=iSlotArray.Count();
	aStream.WriteInt32L(count);
	TInt i=0;
	for (; i<count; i++)
		{
		iSlotArray[i].ExternalizeL(aStream);
		}
	} // CSmsMessage::ExternalizeWithoutBufferAndVersionL


/**
 *  @internalComponent
 *  Internalises the CSmsBufferBase.
 *  
 *  @param aStream Stream to read from
 *  @capability None
 */
EXPORT_C void CSmsMessage::InternalizeBufferL(RReadStream& aStream)
	{
	aStream >> *iBuffer;
	} // CSmsMessage::InternalizeBufferL


/**
 *  @internalComponent
 *  Externalises the CSmsBufferBase.
 *  
 *  @param aStream Stream to write to
 *  @capability None
 */
EXPORT_C void CSmsMessage::ExternalizeBufferL(RWriteStream& aStream) const
	{
	aStream << *iBuffer;
	} // CSmsMessage::ExternalizeBufferL


/**
 *  @internalComponent
 *  Internalises the message version.
 *  
 *  @param aStream Stream to read from
 *  @capability None
 */
EXPORT_C void CSmsMessage::InternalizeVersionL(RReadStream& aStream)
	{
	TInt32 versionNumber = ESmsMessageV0;
	TRAPD(err,versionNumber=aStream.ReadInt32L());
	if(err==KErrEof)
		{
		versionNumber=ESmsMessageV0;
		}

	iVersion=static_cast<TSmsMessageVersion> (versionNumber);
	} // CSmsMessage::InternalizeVersionL


/**
 *  @internalComponent
 *  Externalises the message version.
 *  
 *  @param aStream Stream to write to
 *  @capability None
 */
EXPORT_C void CSmsMessage::ExternalizeVersionL(RWriteStream& aStream) const
	{
	aStream.WriteInt32L(iVersion);
	} // CSmsMessage::ExternalizeVersionL


/**
 *  @publishedAll
 *  
 *  Returns a reference to a specialisation of the class CSmsIEOperation. Clients can use this sub-class
 *  to access the attributes of a specific type of information element encapsulated inside the CSmsMessage.
 *  The ownership to the CSmsIEOperation class belongs to the CSmsMessage. When the CSmsMessage is deleted,
 *  the CSmsIEOperation will also be deleted and the reference will become stale.
 *  
 *  @param aId
 *  Specifies the sub class of CSmsIEOperation required.
 *  @leave KErrNotSupported
 *  When there is not accessor class available for the specified type of information element.
 *  @capability None
 */
EXPORT_C CSmsIEOperation& CSmsMessage::GetOperationsForIEL(CSmsInformationElement::TSmsInformationElementIdentifier aId) const
    {
    LOGGSMU1("CSmsMessage::GetOperationsForIEL()");

    if (iVersion < CSmsMessage::ESmsMessageV1)
        {
        LOGGSMU2("CSmsMessage::GetOperationsForIEL, Operation not supported, Msg Version %d", iVersion);
        User::Leave(KErrNotSupported);
        }

    return iAdditionalInfo->GetIEOperationL(aId);
    } // CSmsMessage::GetOperationsForIEL

EXPORT_C CSmsNonIEOperation& CSmsMessage::GetOperationsForNonIEL(TSmsNonIEIdentifier aId) const
	{
	LOGGSMU1("CSmsMessage::GetOperationsForNonIEL");

	if (iVersion < CSmsMessage::ESmsMessageV2)
		{
		LOGGSMU2("GetOperationsForNonIEL not supported, Msg Version %d", iVersion);
		User::Leave(KErrNotSupported);
		}

	return iAdditionalInfo->GetNonIEOperationL(aId);
	} // CSmsMessage::GetOperationsForNonIEL


void CSmsMessage::CreateControlIEOperationsClassesL()
    {
 	LOGGSMU1("CSmsMessage::CreateControlIEOperationsClassesL()");

    CSmsIEOperation* iEOperation = NULL;

    iEOperation = CSmsIEOperation::NewL(CSmsInformationElement::ESmsHyperLinkFormat, *this,	*iCharacterSetConverter, iFs);
    iAdditionalInfo->SetIEOperationL(iEOperation);

    iEOperation = CSmsIEOperation::NewL(CSmsInformationElement::ESmsReplyAddressFormat, *this,	*iCharacterSetConverter, iFs);
    iAdditionalInfo->SetIEOperationL(iEOperation);

    iEOperation = CSmsIEOperation::NewL(CSmsInformationElement::ESmsEnhanceVoiceMailInformation, *this,	*iCharacterSetConverter, iFs);
    iAdditionalInfo->SetIEOperationL(iEOperation);

    iEOperation = CSmsIEOperation::NewL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, *this,	*iCharacterSetConverter, iFs);
    iAdditionalInfo->SetIEOperationL(iEOperation);
    
    iEOperation = CSmsIEOperation::NewL( CSmsInformationElement::ESmsIEISMSCControlParameters, *this,	*iCharacterSetConverter, iFs);
    iAdditionalInfo->SetIEOperationL(iEOperation);
    } // CSmsMessage::CreateControlIEOperationsClassesL

    
void CSmsMessage::CreateControlNonIEOperationsClassesL()
    {
    CSmsNonIEOperation* nonIEOperation = NULL;

    nonIEOperation = CSmsNonIEOperation::NewL(ESmsTPSRRParameter, *this);
    iAdditionalInfo->SetNonIEOperationL(nonIEOperation);

	nonIEOperation = CSmsNonIEOperation::NewL(ESmsIncompleteClass0MessageParameter, *this);
	iAdditionalInfo->SetNonIEOperationL(nonIEOperation);
	} // CSmsMessage::CreateControlNonIEOperationsClassesL


/**
 *  Gets the scheme of the status report.
 *  
 *  @return Staus Report Scheme 
 */
EXPORT_C TSmsStatusReportScheme CSmsMessage::Scheme() const
	{
	return iAdditionalInfo->GetStatusReportScheme().Id();
	}

/**
 *  @publishedAll
 *  
 *  Used by the SMS Stack to indicate that when the message was decoded, it was determined
 *  to be on the SIM. If the message's DCS byte is configured for automatic delete or the
 *  PID is set to Type 0, the message may subsequently have been deleted from the SIM during
 *  decoding in which case its storage status is unstored.
 *  
 *  @param aOnSim
 *  Used to indicate that the message was on the SIM when it was decoded.
 *  @capability None
 */
EXPORT_C void  CSmsMessage::SetDecodedOnSIM(TBool aOnSim)
    {
 	LOGGSMU2("CSmsMessage::SetDecodedOnSIM(): %d", aOnSim);

    if (aOnSim)
        {
        iFlags = iFlags | EDecodedOnSimBit;
        }
    else
        {
        iFlags = iFlags & ~EDecodedOnSimBit;
        }
    } // CSmsMessage::SetDecodedOnSIM


/**
 *  @publishedAll
 *  
 *  Used by the SMS Stack to indicate that when the message was decoded, it was determined
 *  to be on the SIM. If the message's DCS byte is configured for automatic delete or the
 *  PID is set to Type 0, the message may subsequently have been deleted from the SIM during
 *  decoding in which case its storage status is unstored.
 *  
 *  @return
 *  True if the message was on the SIM during decoding,
 *  False otherwise.
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::DecodedOnSim()
    {
    LOGGSMU1("CSmsMessage::DecodedOnSim()");

    if (iFlags & EDecodedOnSimBit)
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    } // CSmsMessage::DecodedOnSim


/**
 *  @publishedAll
 *  
 *  Used by the SMS Stack to indicate that when the message was decoded, it was determined
 *  that it should be forwarded to the client. The message will not be forwarded to the
 *  client when the PID byte is set to type 0 (except by default for class 0 and class 2 messages).
 *  
 *  @param forward
 *  Used to indicate that the message needs to be forwarded to clients.
 *  @capability None
 */
EXPORT_C void CSmsMessage::SetForwardToClient(TBool aForward)
    {
 	LOGGSMU2("CSmsMessage::SetForwardToClient(): %d", aForward);

    if (aForward)
        {
        iFlags = iFlags | EForwardToClientBit;
        }
    else
        {
        iFlags = iFlags & ~EForwardToClientBit;
        }
    } // CSmsMessage::SetForwardToClient


/**
 *  @publishedAll
 *  
 *  Used by the SMS Stack to indicate that when the message was decoded, it was determined
 *  that is should be forwarded to the client. The message will not be forwarded to the client
 *  when the PID byte is set to type 0 (except by default for class 0 and class 2 messages).
 *  
 *  @return
 *  True if the message is to be forwarded to clients
 *  False otherwise.
 *  @capability None
 */
EXPORT_C TBool CSmsMessage::ForwardToClient()
    {
    LOGGSMU1("CSmsMessage::ForwardToClient()");

    if (iFlags & EForwardToClientBit)
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    } // CSmsMessage::ForwardToClient
