// 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:

// Implements CSmsReassemblyStore and CSmsSegmentationStore.

// 

//

/**

 @file

*/

#include <e32svr.h>

#include <es_ini.h>

#include "smspstor.h"

#include "smspmain.h"

#include "smsuaddr.H"

#include "Gsmumsg.h"

#include "gsmubuf.h"

#include <logwrap.h>

#include <logwraplimits.h>

#include "Gsmuelem.h"

#include "gsmuieoperations.h"

#include "gsmunonieoperations.h"

LOCAL_C TPtrC TrimLeadingZeros(const TDesC& aString)

	{

	LOGSMSPROT1("CSARStore::ExternalizeEntryArrayL()");

	const TInt len = aString.Length();

	if (len == 0)

		return aString;

	const TUint16* startChar = &aString[0];

	const TUint16* endChar = &aString[len-1];

	while (startChar <= endChar && *startChar == '0')

		{

		++startChar;

		}

	return TPtrC(startChar, endChar - startChar + 1);

	} // TrimLeadingZeros

/**

 *  Creates new CSmsReassemblyStore instance

 *  

 *  @param aFs  File Server handle.

 */

CSmsReassemblyStore* CSmsReassemblyStore::NewL(RFs& aFs)

	{

	LOGSMSPROT1("CSmsReassemblyStore::NewL()");

	CSmsReassemblyStore*  self = new (ELeave) CSmsReassemblyStore(aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	} // CSmsReassemblyStore::NewL

/**

 *  Creates and starts timer

 */

void CSmsReassemblyStore::ConstructL()

	{

	LOGSMSPROT1("CSmsReassemblyStore::ConstructL()");

	//

	// Generate the full path to the reassembly store.

	//

	PrivatePath(iFullPathBuf);

	iFullPathBuf.Append(KReassemblyStoreName);

 	iLastReceivedTime.UniversalTime();

 	iLastRealTime = iLastReceivedTime;

	} // CSmsReassemblyStore::ConstructL

/**

 *  Destructor

 */

CSmsReassemblyStore::~CSmsReassemblyStore()

	{

	// NOP

	} // CSmsReassemblyStore::~CSmsReassemblyStore

void CSmsReassemblyStore::UpdateLogServerIdL(TInt aIndex, TLogId aLogServerId)

	{

	LOGSMSPROT1("CSmsReassemblyStore::UpdateLogServerIdL()");

	TSmsReassemblyEntry entry(reinterpret_cast<const TSmsReassemblyEntry&>(Entries()[aIndex]));

	if (entry.LogServerId() != aLogServerId)

		{

		entry.SetLogServerId(aLogServerId);

		BeginTransactionLC();

		ChangeEntryL(aIndex, entry);

		CommitTransactionL();

		}

	} // CSmsReassemblyStore::UpdateLogServerIdL

/**

 *  Searches the reassembly store for a CSmsMessage and returns its index.

 *

 *  @param aSmsMessage  Message to search for.

 *  @param aPassed      Determines if we are searching for a message already

 *                      passed to the client.

 *  @param aIndex       Return index value.

 *

 *  @return True and an index if aSmsMessage is found in this reassembly store

 */

TBool CSmsReassemblyStore::FindMessageL(const CSmsMessage& aSmsMessage,

										TBool aPassed,

										TInt& aIndex)

 	{

 	LOGSMSPROT1("CSmsReassemblyStore::FindMessageL()");

	//

	// Parse the GSM data from the SMS message...

	//

	TGsmSmsTelNumber  parsedAddress;

	aSmsMessage.ParsedToFromAddress(parsedAddress);

	//

	// Search the store for a matching message...

	//

 	for (TInt index = Entries().Count() - 1;  index >= 0;  index--)

 		{

		const TSmsReassemblyEntry&  entry = reinterpret_cast<const TSmsReassemblyEntry&>(Entries()[index]);

		// Always search the basic types first and strings last!

		if (entry.PduType() == aSmsMessage.Type()  &&

			entry.PassedToClient() == aPassed  &&

			entry.Storage() == aSmsMessage.Storage()  &&

			entry.Time() == aSmsMessage.Time()  &&

			entry.Description2().Right(8) == parsedAddress.iTelNumber.Right(8))

 			{

			//

			// Found!

			//

			LOGSMSPROT2("CSmsReassemblyStore::FindMessage(): Found! index=%d", index);

			aIndex = index;

			return ETrue;

			}

 		}

	//

	// Not found...

	//

	LOGSMSPROT1("CSmsReassemblyStore::FindMessage(): Not found!");

 	return EFalse;

 	} // CSmsReassemblyStore::FindMessageL

/**

 *  Adds Pdu to reassembly store

 *  

 *  @param aSmsMessage  PDU to 

 *  @param aGsmSms Used to

 *  @param aIndex Used to

 *  @param aComplete Used to

 *  @param aServiceCenterAddressPresent Used to

 */

void CSmsReassemblyStore::MatchPDUToExistingMessage(const CSmsMessage& aSmsMessage,

													TInt& aIndex)

	{

	LOGSMSPROT1("CSmsReassemblyStore::MatchPDUToExistingMessage()");

	__ASSERT_ALWAYS(!aSmsMessage.IsDecoded(), SmspPanic(KSmspPanicMessageConcatenated));

	aIndex = KErrNotFound;

	TGsmSmsTelNumber  parsedAddress;

	aSmsMessage.ParsedToFromAddress(parsedAddress);

	//

	// Search the reassembly store for a matching entry (start from the

	// end as the most recent PDUs appear at the end)...

	//

	TInt reassemblyCount = Entries().Count();

	for (TInt index = reassemblyCount - 1;  index >= 0;  index--)

		{

		TSmsReassemblyEntry&  entry = (TSmsReassemblyEntry&) Entries()[index];

		// Always check the fields in order of the quickest to check...

		if (entry.IsComplete() == EFalse  &&

		    entry.PduType() == aSmsMessage.Type()  &&

			entry.Storage() == aSmsMessage.Storage())

			{

			TInt  telLen = Min(entry.Description2().Length(),

					           parsedAddress.iTelNumber.Length());

			if (entry.Description2().Right(telLen) == parsedAddress.iTelNumber.Right(telLen)  &&

		        entry.Total() == aSmsMessage.SmsPDU().NumConcatenatedMessagePDUs()  &&

			    entry.Reference() == aSmsMessage.SmsPDU().ConcatenatedMessageReference())

				{

				//

				// Found it!

				//

				aIndex = index;

				break;

				}

			}

		}

	LOGSMSPROT3("CSmsReassemblyStore::MatchPDUToExistingMessage(): reassemblyCount=%d, aIndex=%d", reassemblyCount, aIndex);

	} // CSmsReassemblyStore::MatchPDUToExistingMessage

void CSmsReassemblyStore::UpdateExistingMessageL(const CSmsMessage& aSmsMessage,

												 const TGsmSms& aGsmSms, TInt aIndex,

												 TBool& aComplete,

												 TBool& aDuplicateMsgRef,

												 TBool& aDuplicateSlot)

	{

	LOGSMSPROT1("CSmsReassemblyStore::UpdateExistingMessageL()");

	aComplete        = EFalse;

	aDuplicateMsgRef = EFalse;

	aDuplicateSlot   = EFalse;

	//

	// Read the segment from the store into a CSmsMessage buffer...

	//

	TSmsReassemblyEntry  entry = (TSmsReassemblyEntry&) Entries()[aIndex];

	CArrayFix<TInt>*  indexArray = new(ELeave) CArrayFixFlat<TInt>(8);

	CleanupStack::PushL(indexArray);

	CArrayFixFlat<TGsmSms>*  smsArray = new(ELeave) CArrayFixFlat<TGsmSms>(8);

	CleanupStack::PushL(smsArray);

	CSmsBuffer*  buffer = CSmsBuffer::NewL();

	CSmsMessage*  smsMessage = CSmsMessage::NewL(iFs, CSmsPDU::ESmsDeliver, buffer);

	CleanupStack::PushL(smsMessage);

	InternalizeEntryL(entry.DataStreamId(), *smsMessage, *indexArray, *smsArray);

	//

	// Check if this is a duplicated enumerated PDU (e.g. on the SIM or phone memory)

	// or a duplicated PDU (e.g. in the Reassembly Store)...

	//

	TInt  concatPDUIndex = aSmsMessage.SmsPDU().ConcatenatedMessagePDUIndex();

	if (smsMessage->Storage() == CSmsMessage::ESmsSIMStorage  ||

		smsMessage->Storage() == CSmsMessage::ESmsCombinedStorage)

		{

		//

		// In most cases this PDU is being enumerated, but not always. It is

		// possible for the PDU to be stored on the SIM first before it is

		// received.

		//

		const TGsmSmsSlotEntry&  newSlot = aSmsMessage.iSlotArray[0];

		TInt  slotArrayCount = smsMessage->iSlotArray.Count();

		for (TInt slotNum = 0;  slotNum < slotArrayCount;  slotNum++ )

			{

			const TGsmSmsSlotEntry&  slot = smsMessage->iSlotArray[slotNum];

			if (slot.iIndex == newSlot.iIndex  && slot.iStore == newSlot.iStore)

				{

				LOGSMSPROT1("CSmsReassemblyStore::UpdateExistingMessageL(): Duplicate enumerated PDU.");

				// It is a duplicate that was already stored on the SIM...

				aDuplicateSlot = ETrue;

				break;

				}

			}

		}

	TInt  indexArrayCount = indexArray->Count();

	for (TInt index = 0;  index < indexArrayCount;  index++ )

		{

		if (indexArray->At(index) == concatPDUIndex)

			{

			LOGSMSPROT1("CSmsReassemblyStore::UpdateExistingMessageL(): Duplicate concatenated PDU.");

			// The PDU is already stored in the reassembly store.

			aDuplicateMsgRef = ETrue;

			break;

			}

		}

	if (aDuplicateMsgRef  ||  aDuplicateSlot)

		{

		CleanupStack::PopAndDestroy(3, indexArray); // smsMessage, smsArray, indexArray

		return;

		}

	//

	// If the PDU is stored then add the slot information...

	//

	if (smsMessage->Storage() == CSmsMessage::ESmsSIMStorage  ||

		smsMessage->Storage() == CSmsMessage::ESmsCombinedStorage)

		{

		smsMessage->AddSlotL(aSmsMessage.iSlotArray[0]);

		}

	//

	// If the PDU is Unsent or Unread, then store that information...

	//

	NMobileSmsStore::TMobileSmsStoreStatus  status = aSmsMessage.Status();

	if (status == NMobileSmsStore::EStoredMessageUnsent  ||

		status == NMobileSmsStore::EStoredMessageUnread)

		{

		smsMessage->SetStatus(status);

		}

	//

	// Does this PDU mean the message is complete? If so then decode the message,

	// reset the index and sms arrays (to save space for completed SMSs).

	//

	indexArray->AppendL(concatPDUIndex);

	smsArray->AppendL(aGsmSms);

	if (smsArray->Count() == smsMessage->SmsPDU().NumConcatenatedMessagePDUs())

		{

		smsMessage->DecodeMessagePDUsL(*smsArray);

		indexArray->Reset();

		smsArray->Reset();

		aComplete = ETrue;

		}

	//

	// Write the entry back into the store...

	//

	TStreamId  streamid = entry.DataStreamId();

	smsMessage->SetLogServerId(entry.LogServerId());

	BeginTransactionLC();

	ExternalizeEntryL(streamid, *smsMessage, *indexArray, *smsArray);

	PopulateEntry(entry, *smsMessage, smsArray->Count());

	ChangeEntryL(aIndex, entry);

	CommitTransactionL();

	CleanupStack::PopAndDestroy(3, indexArray); // smsMessage, smsArray, indexArray

	} // CSmsReassemblyStore::UpdateExistingMessageL

void CSmsReassemblyStore::NewMessagePDUL(TInt& aIndex,CSmsMessage& aSmsMessage,const TGsmSms& aGsmSms)

	{

	LOGSMSPROT1("CSmsReassemblyStore::NewMessagePDUL");

	CArrayFix<TInt>* indexarray=new(ELeave) CArrayFixFlat<TInt>(8);

	CleanupStack::PushL(indexarray);

	CArrayFixFlat<TGsmSms>* smsarray=new(ELeave) CArrayFixFlat<TGsmSms>(8);

	CleanupStack::PushL(smsarray);

	TInt index=aSmsMessage.IsDecoded()? 0: aSmsMessage.SmsPDU().ConcatenatedMessagePDUIndex();

	indexarray->AppendL(index);

	smsarray->AppendL(aGsmSms);

	aIndex=Entries().Count();

	CreateEntryL(aSmsMessage,*indexarray,*smsarray);

	CleanupStack::PopAndDestroy(2);

	} // CSmsReassemblyStore::NewMessagePDUL

void CSmsReassemblyStore::GetMessageL(TInt aIndex,CSmsMessage& aSmsMessage)

	{

	LOGSMSPROT2("CSmsReassemblyStore::GetMessageL [aIndex=%d]", aIndex);

	CArrayFix<TInt>* indexarray=new(ELeave) CArrayFixFlat<TInt>(8);

	CleanupStack::PushL(indexarray);

	CArrayFixFlat<TGsmSms>* smsarray=new(ELeave) CArrayFixFlat<TGsmSms>(8);

	CleanupStack::PushL(smsarray);

	InternalizeEntryL(Entries()[aIndex].DataStreamId(),aSmsMessage,*indexarray,*smsarray);

	TInt logid=Entries()[aIndex].LogServerId();

	if(aSmsMessage.LogServerId() == KLogNullId &&  logid != KLogNullId)

		aSmsMessage.SetLogServerId(logid);

	CleanupStack::PopAndDestroy(2); // smsarray, indexarray

	} // CSmsReassemblyStore::GetMessageL

/**

 *  internalize all the entries from the permanent file store to internal memory

 *  

 *  NOTE! You have to call CSARStore::OpenFileLC() before calling this function

 */

void CSmsReassemblyStore::InternalizeEntryL(const TStreamId& aStreamId,CSmsMessage& aSmsMessage,CArrayFix<TInt>& aIndexArray,CArrayFix<TGsmSms>& aSmsArray)

	{

	LOGSMSPROT2("CSmsReassemblyStore::InternalizeEntryL Start [sid=%d]", aStreamId.Value());

	RStoreReadStream readstream;

	readstream.OpenLC(FileStore(),aStreamId);

	readstream >> aSmsMessage;

	TInt count=readstream.ReadInt32L();

	aIndexArray.Reset();

	TInt i;

	for (i=0; i<count; i++)

		{

		TInt index=readstream.ReadInt32L();

		aIndexArray.AppendL(index);

		}

	count=readstream.ReadInt32L();

	if(count!=aIndexArray.Count())

		User::Leave(KErrCorrupt);

	aSmsArray.Reset();

	for (i=0; i<count; i++)

		{

		RMobileSmsMessaging::TMobileSmsGsmTpdu pdu;

		readstream >> pdu;

		TGsmSms sms;

		sms.SetPdu(pdu);

		aSmsArray.AppendL(sms);

		}

	CleanupStack::PopAndDestroy();

	LOGSMSPROT2("CSmsReassemblyStore::InternalizeEntryL End [count=%d]", count);

	} // CSARStore::OpenFileLC

/**

 *  externalizes all the entries from the internal memory to the permanent file store

 *  

 *  NOTE! You have to call CSARStore::OpenFileLC() before calling this function

 */

void CSmsReassemblyStore::ExternalizeEntryL(TStreamId& aStreamId,const CSmsMessage& aSmsMessage,const CArrayFix<TInt>& aIndexArray,const CArrayFix<TGsmSms>& aSmsArray)

	{

	LOGSMSPROT2("CSmsReassemblyStore::ExternalizeEntryL Start [sid=%d]", aStreamId.Value());

	RStoreWriteStream writestream;

	if (aStreamId==KNullStreamId)

		aStreamId=writestream.CreateLC(FileStore());

	else

		writestream.ReplaceLC(FileStore(),aStreamId);

	writestream << aSmsMessage;

	TInt count=aIndexArray.Count();

	__ASSERT_ALWAYS(count==aIndexArray.Count(),SmspPanic(KSmspPanicBadIndexArray));

	writestream.WriteInt32L(count);

	TInt i=0;

	for (; i<count; i++)

		writestream.WriteInt32L(aIndexArray[i]);

	count=aSmsArray.Count();

	writestream.WriteInt32L(count);

	for (i=0; i<count; i++)

		{

		RMobileSmsMessaging::TMobileSmsGsmTpdu pdu;

		pdu=aSmsArray[i].Pdu();

		writestream << pdu;

		}

	writestream.CommitL();

	CleanupStack::PopAndDestroy();

	LOGSMSPROT2("CSmsReassemblyStore::ExternalizeEntryL End [count=%d]", count);

	} // CSARStore::OpenFileLC

void CSmsReassemblyStore::PopulateEntry(TSmsReassemblyEntry& aEntry,const CSmsMessage& aSmsMessage,TInt aNumSmss)

	{

	LOGSMSPROT1("CSmsReassemblyStore::PopulateEntry");

	aEntry.SetReference(0);

	aEntry.SetTotal(1);

	aEntry.SetCount(1);

	if (aSmsMessage.TextPresent())

		{

		if (aSmsMessage.SmsPDU().TextConcatenated())

			{

			aEntry.SetReference(aSmsMessage.SmsPDU().ConcatenatedMessageReference());

			aEntry.SetTotal(aSmsMessage.SmsPDU().NumConcatenatedMessagePDUs());

			aEntry.SetCount(aSmsMessage.IsComplete()? aEntry.Total(): aNumSmss);

			}

		TInt bits7to4=aSmsMessage.SmsPDU().Bits7To4();

		TInt count=aSmsMessage.SmsPDU().UserData().NumInformationElements();

		TInt identifier1=0xFF;

		TInt identifier2=0x00;

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

			{

			TInt identifier=aSmsMessage.SmsPDU().UserData().InformationElement(i).Identifier();

			if ((identifier!=CSmsInformationElement::ESmsIEIConcatenatedShortMessages8BitReference) && (identifier!=CSmsInformationElement::ESmsIEIConcatenatedShortMessages16BitReference))

				{

				if (identifier<identifier1)

					identifier1=identifier;

				if (identifier>identifier2)

					identifier2=identifier;

				}

			}

		if ((bits7to4>=TSmsDataCodingScheme::ESmsDCSMessageWaitingIndicationDiscardMessage) && (bits7to4<=TSmsDataCodingScheme::ESmsDCSMessageWaitingIndicationUCS2))

			aEntry.SetBits7to4andIdentifiers(bits7to4, identifier1, identifier2);

		else

			aEntry.SetBits7to4andIdentifiers(0, identifier1, identifier2);

		}

	//Set the logServerId to aSmsMessage.LogServerId()

	aEntry.SetLogServerId(aSmsMessage.LogServerId());

	const CSmsPDU::TSmsPDUType type(aSmsMessage.Type());

	aEntry.SetPduType(type);

	aEntry.SetPassedToClient(EFalse);

	aEntry.SetStorage(aSmsMessage.Storage());

	if ((type!=CSmsPDU::ESmsSubmitReport) && (type!=CSmsPDU::ESmsDeliverReport))

		{

		//  Strip out spaces etc from address

		TGsmSmsTelNumber parsedaddress;

		aSmsMessage.ParsedToFromAddress(parsedaddress);

		aEntry.SetDescription2(parsedaddress.iTelNumber);

		}

	aEntry.SetTime(aSmsMessage.Time());

	} // CSmsReassemblyStore::PopulateEntry

void CSmsReassemblyStore::CreateEntryL(CSmsMessage& aSmsMessage,const CArrayFix<TInt>& aIndexArray,const CArrayFix<TGsmSms>& aSmsArray)

	{

	LOGSMSPROT1("CSmsReassemblyStore::CreateEntryL");

 	TStreamId streamid=KNullStreamId;

 	if (aSmsMessage.Time() >= iLastRealTime)