// Copyright (c) 2007-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 CPreallocatedFile.

// 

//

/**

 @file

*/

#include "smspclass0stor.h"

#include "gsmubuf.h"

#include "gsmunonieoperations.h"

const TInt KSizeOfPreallocatedFileVersion = sizeof(CPreallocatedFile::TPreAllocatedFileVersion);

const TInt KSizeOfNumberOfEntrySection = sizeof(TInt);

//size of 32-bit checksum

const TInt KSizeOfChecksum = sizeof(TUint32);

const TInt KSizeOfPreAllocatedStoreEntry = sizeof(TSmsPreAllocatedFileStoreReassemblyEntry);

const TInt KSizeOfGsmSmsSlotEntry = sizeof(TGsmSmsSlotEntry);

const TInt KSizeOfIndexEntry = sizeof(TInt);

const TInt KSizeOfSmsGsmPDU = sizeof(RMobileSmsMessaging::TMobileSmsGsmTpdu);

const TInt KSizeOfAContainer = KSizeOfGsmSmsSlotEntry + KSizeOfIndexEntry + KSizeOfSmsGsmPDU;

const TInt KBeginOfMasterHeaderSection = KSizeOfPreallocatedFileVersion;

/**

Static factory constructor. Uses two phase 

construction and leaves nothing on the CleanupStack.

@param aFs  File Server handle.

@param aFileName  Permanent file store name.

@param aThirdUid  Uid of file.

@leave KErrNoMemory

@return A pointer to the newly created CSmsPermanentFileStore object.

@pre A connected file server session must be passed as parameter.

@post CSmsPermanentFileStore object is now fully initialised

@internalComponent

*/

CSmsPermanentFileStore* CSmsPermanentFileStore::NewL(RFs& aFs, const TDesC& aFileName, const TUid& aThirdUid)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::NewL()");

	CSmsPermanentFileStore*  self = new (ELeave) CSmsPermanentFileStore(aFs, aThirdUid);

	CleanupStack::PushL(self);

	self->ConstructL(aFileName);

	CleanupStack::Pop(self);

	return self;

	}

void CSmsPermanentFileStore::ConstructL(const TDesC& aFileName)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::ConstructL()");

	iFileName = aFileName.AllocL();

	}

/**

 *  Constructor.

*/

CSmsPermanentFileStore::CSmsPermanentFileStore(RFs& aFs, const TUid& aThirdUid)

							: iFs(aFs), iFileName(NULL), iThirdUid(aThirdUid), iFileStore(NULL), iEntryArray(KFlatArrayGranularity)

	{

	}

/**

 *  Destructor. It destroys all the member variables.

*/

CSmsPermanentFileStore::~CSmsPermanentFileStore()

	{

	delete iFileName;

	}

/**

It checks & returns whether the file exist or not. If file is there whether

it is corrupted or not.

@internalComponent

*/

TBool CSmsPermanentFileStore::IsFileOK()

	{

	TBool retBool(EFalse);

	TUidType uidtype(KPermanentFileStoreLayoutUid,KSARStoreUid,iThirdUid);

	TEntry entry;

	TInt ret=iFs.Entry(iFileName->Des(), entry);

	//  Check file existence & corruption

	if ((ret == KErrNone) && (entry.iType == uidtype))

		{

		retBool = ETrue;

		}

	return retBool;

	}

/**

It creates a permanent store file.

@internalComponent

*/

void CSmsPermanentFileStore::CreateL()

	{

	LOGSMSPROT1("CSmsPermanentFileStore::CreateL()");

	TUidType uidtype(KPermanentFileStoreLayoutUid,KSARStoreUid,iThirdUid);

	iFileStore=CPermanentFileStore::ReplaceL(iFs, iFileName->Des(), EFileShareExclusive|EFileStream|EFileRead|EFileWrite);

	iFileStore->SetTypeL(uidtype);

	iEntryArray.Reset();

	ExternalizeEntryArrayL();

	iFileStore->CommitL();

	// Close it to make sure that file is created correctly (defensive approach).

	Close();

	//Again Open the file

	OpenL();

	}

/**

It opens the permanent store file and internalizes the entries.

@internalComponent

*/

void CSmsPermanentFileStore::OpenL()

	{

	LOGSMSPROT1("CSmsPermanentFileStore::OpenL()");

	iFileStore=CPermanentFileStore::OpenL(iFs,iFileName->Des(),EFileShareExclusive|EFileStream|EFileRead|EFileWrite);

	InternalizeEntryArrayL();

	}

/**

It closes the permanent store file.

@internalComponent

*/

void CSmsPermanentFileStore::Close()

	{

	LOGSMSPROT1("CSmsPermanentFileStore::Close()");

	delete iFileStore;

	iFileStore = NULL;

	iEntryArray.Reset();

	}

/*

This function cleans its entries against the passed entries.

This is needed because there might be a scenario where user has deleted a message

but the corresponding message is not deleted from permanent store file

due to out-of-disk condition. But the entry is invalid because

it is no more in the pre-allocated file which contains master header info.

And also at the time of forwarding an incomplete message a forwarded 

message has not been deleted due to above reason.

This function also compacts the store after deletion.

@param aEntryArray entray array against whose clean up is carried out.

@internalComponent

*/

void CSmsPermanentFileStore::CleanupEntriesWithCompactL(const CArrayFix<TSmsPreAllocatedFileStoreReassemblyEntry>& aEntryArray)

	{

    // Ignore in code coverage - a previous CleanupEntries would need to have failed with KErrDiskFull

	BULLSEYE_OFF

	LOGSMSPROT1("CSmsPermanentFileStore::CleanupEntriesWithCompactL()");

	iCompact = ETrue;

	CleanupEntriesL(aEntryArray);

	BULLSEYE_RESTORE	

	}

/*

This function cleans its entries against the passed entries.

This is needed because there migth be a scenario where user has deleted a message

but the corresponding message is not deleted from permanent store file

due to out-of-disk condition. But the entry is invalid because

it is no more in the pre-allocated file which contains master header info.

And also at the time of forwarding an incomplete message a forwarded 

message has not been deleted due to above reason.

@param aEntryArray entray array against whose clean up is carried out.

@internalComponent

*/

void CSmsPermanentFileStore::CleanupEntriesL(const CArrayFix<TSmsPreAllocatedFileStoreReassemblyEntry>& aEntryArray)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::CleanupEntriesL()");

	TInt reassemblyCount = iEntryArray.Count();

	TInt index, index2;

	for (index = 0;  index < reassemblyCount;  index++)

		{

		for (index2 = 0;  index2 < aEntryArray.Count();  index2++)

			{

			if (iEntryArray[index].Reference() == aEntryArray[index2].Reference()  &&

			    iEntryArray[index].Total() == aEntryArray[index2].Total()  &&

			    iEntryArray[index].PduType() == aEntryArray[index2].PduType()  &&

				iEntryArray[index].Storage() == aEntryArray[index2].Storage()  &&

				iEntryArray[index].Description2() == aEntryArray[index2].Description2())

				{

				if (aEntryArray[index2].NumberOfPDUsForwardToClient() > 0)

					{

					//Internalize the entries.

					CSmsBuffer*  buffer = CSmsBuffer::NewL();

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

					CleanupStack::PushL(smsMessage);

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

					CleanupStack::PushL(indexArray);

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

					CleanupStack::PushL(smsArray);

					InternalizeEntryL(index, *smsMessage, *indexArray, *smsArray);

					TInt noOfForwardedEntries = 0;

					for (TInt j=indexArray->Count(); j>0 ;j--)

						{

						TUint8 bitMapIndex = (indexArray->At(j-1)-1)/8;

						TUint8 bitPos = (indexArray->At(j-1)-1)%8;

						TUint8 bitMap;

						TSmsPreAllocatedFileStoreReassemblyEntry entry;

						entry = aEntryArray[index2];

						entry.GetBitMap(bitMapIndex, bitMap);

						TUint8 tmpBitMap = 1;

						tmpBitMap <<= bitPos;

						if (tmpBitMap == (bitMap & tmpBitMap))

							{

							noOfForwardedEntries++;

							indexArray->Delete(j-1);

							smsArray->Delete(j-1);

							}

						}

					if (noOfForwardedEntries > 0)

						{

						TStreamId streamId = iEntryArray[index].DataStreamId();

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

						}

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

					}

				break;

				}

			}

		if (index2 == aEntryArray.Count())

			{

			DeleteEntryL(index);

			}

		}

	}

/**

It internalizes its entry array.

@internalComponent

*/

void CSmsPermanentFileStore::InternalizeEntryArrayL()

	{

	LOGSMSPROT1("CSmsPermanentFileStore::InternalizeEntryArrayL()");

	iEntryArray.Reset();

	TStreamId headerid=iFileStore->Root();

	RStoreReadStream stream;

	stream.OpenLC(*iFileStore,headerid);

	TInt count=stream.ReadInt32L();

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

		{

		TSmsReassemblyEntry sarentry;

		stream >> sarentry;

		iEntryArray.AppendL(sarentry);

		}

	CleanupStack::PopAndDestroy();  //  stream

	}

/**

It externalizes its entry array.

@internalComponent

*/

void CSmsPermanentFileStore::ExternalizeEntryArrayL()

	{

	LOGSMSPROT4("CSmsPermanentFileStore::ExternalizeEntryArrayL(): this=0x%08X count=%d headerid=%d]",

			 this, iEntryArray.Count(), iFileStore->Root().Value());

	TStreamId headerid=iFileStore->Root();

	RStoreWriteStream stream;

	if (headerid==KNullStreamId)

		{

		headerid=stream.CreateLC(*iFileStore);

		iFileStore->SetRootL(headerid);

		}

	else

		{

		stream.ReplaceLC(*iFileStore,headerid);

		}

	TInt count1=iEntryArray.Count();

	TInt count2=0;

	TInt i=0;

	for (; i<count1; i++)

		{

		if (!iEntryArray[i].IsDeleted())

			{

			count2++;

			}

		}

	stream.WriteInt32L(count2);

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

		{

		if (!iEntryArray[i].IsDeleted())

			{

			stream << iEntryArray[i];

			}

		}

	stream.CommitL();

	CleanupStack::PopAndDestroy(&stream);

	}

/*

It adds the new message in permanent store file.

@param aIndex (output) index number on which message is added.

@param aSmsMessage reference to sms message to be added.

@param aGsmSms reference to GsmSms object to be added.

@internalComponent

*/

void CSmsPermanentFileStore::AddNewMessageL(TInt& aIndex, CSmsMessage& aSmsMessage,const TGsmSms& aGsmSms)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::AddNewMessageL");

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

	CleanupStack::PushL(indexArray);

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

	CleanupStack::PushL(smsArray);

	//Index must initialize to 0.

	TInt index = 0;

	if (!aSmsMessage.IsDecoded())

		{

		index = aSmsMessage.SmsPDU().ConcatenatedMessagePDUIndex();

		}

	indexArray->AppendL(index);

	smsArray->AppendL(aGsmSms);

	TStreamId streamid = KNullStreamId;

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

	TSmsReassemblyEntry tmpEntry;

	//Fill-up entry information...

	CReassemblyStoreUtility::PopulateEntry(tmpEntry, aSmsMessage, 1);

	// Update Data stream id.

	tmpEntry.SetDataStreamId(streamid);

	aIndex = iEntryArray.Count();

	AddEntryL(tmpEntry);

	CleanupStack::PopAndDestroy(2);	//indexArray, smsArray

	}

/*

It updates the existing message in permanent store file.

@param aIndex index number on which message is to be updated.

@param aSmsMessage reference to sms message to be updated.

@param aIndexArray array of index of all the PDUs.

@param aSmsArray array of sms of all the PDUs.

@internalComponent

*/

void CSmsPermanentFileStore::UpdateExistingMessageL(TInt aIndex, const CSmsMessage& aSmsMessage,const CArrayFix<TInt>& aIndexArray,const CArrayFix<TGsmSms>& aSmsArray)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::UpdateExistingMessageL()");

	TStreamId  streamid = iEntryArray[aIndex].DataStreamId();

	ExternalizeEntryL(streamid, aSmsMessage, aIndexArray, aSmsArray);

	TSmsReassemblyEntry entry;

	CReassemblyStoreUtility::PopulateEntry(entry, aSmsMessage, aSmsArray.Count());

	entry.SetDataStreamId(streamid);

	ChangeEntryL(aIndex, entry);

	}

/*

It matches the entry with entry in permanent store file & returns

the index. If not found it returns KErrNotFound.

@param aEntry reference to entry information.

@param aIndex (output) returns the index number.

@internalComponent

*/

void CSmsPermanentFileStore::MatchEntryToExistingMessage(const TReassemblyEntry& aEntry,

													TInt& aIndex)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::MatchEntryToExistingMessage()");

	aIndex = KErrNotFound;

	//

	// Search the reassembly store for a matching entry...

	//

	TInt reassemblyCount = iEntryArray.Count();

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

		{

		TSmsReassemblyEntry&  entry = iEntryArray[index];

		if (entry.Reference() == aEntry.Reference()  &&

			entry.Total() == aEntry.Total()  &&

			entry.PduType() == aEntry.PduType()  &&

			entry.Storage() == aEntry.Storage()  &&

			entry.Description2() == aEntry.Description2())

			{

			//

			// Found it!

			//

			aIndex = index;

			break;

			}

		}

	LOGSMSPROT2("CSmsPermanentFileStore::MatchEntryToExistingMessage(): aIndex=%d", aIndex);

	}

/*

It updates the log server id of the message.

@param aIndex index number of the message to be updated.

@param aLogServerId log server id.

@internalComponent

*/

void CSmsPermanentFileStore::UpdateLogServerIdL(TInt& aIndex, TLogId aLogServerId)

	{

	LOGSMSPROT1("CSmsPermanentFileStore::UpdateLogServerIdL");

	TSmsReassemblyEntry entry;

	entry = iEntryArray[aIndex];

	if (entry.LogServerId() != aLogServerId)

		{

		entry.SetLogServerId(aLogServerId);

		ChangeEntryL(aIndex, entry);

		}

	}

/*

It sets the message passed to client or not.

@param aIndex index number of the message to be updated.

@param aBool boolean value indicating whether message is passes or not.

@internalComponent

*/

void CSmsPermanentFileStore::SetPassedToClientL(TInt aIndex, TBool aBool)

	{

	LOGSMSPROT2("CSmsPermanentFileStore::SetPassedToClientL(): aIndex=%d", aIndex);

	TSmsReassemblyEntry entry;

	entry = iEntryArray[aIndex];

	if (entry.PassedToClient() != aBool)

		{

		entry.SetPassedToClient(aBool);

		ChangeEntryL(aIndex, entry);

		}

	}

/*

It adds the new entry in the existing entry array.

@param aEntry entry to be added.

@internalComponent

*/

void CSmsPermanentFileStore::AddEntryL(TSmsReassemblyEntry& aEntry)

	{

	iEntryArray.AppendL(aEntry);

	iEntryArray[iEntryArray.Count()-1].SetIsAdded(ETrue);

	}

/*

It changes the existing entry with new entry.

@param aIndex index number of the entry which will be changed.

@param aNewEntry entry to be updated.

@internalComponent

*/

void CSmsPermanentFileStore::ChangeEntryL(TInt aIndex,const TSmsReassemblyEntry& aNewEntry)

	{

	LOGSMSPROT2("CSmsPermanentFileStore::ChangeEntryL(): aIndex=%d", aIndex);

	iEntryArray[aIndex].SetIsDeleted(ETrue);

	iEntryArray.InsertL(aIndex,aNewEntry);

	iEntryArray[aIndex].SetIsAdded(ETrue);

	}

/*

It deletes the entry.

@param aIndex index number of the entry which will be deleted.

@internalComponent

*/

void CSmsPermanentFileStore::DeleteEntryL(TInt aIndex)

	{

	iFileStore->DeleteL(iEntryArray[aIndex].DataStreamId());

	iEntryArray[aIndex].SetIsDeleted(ETrue);

	}

/*

It externalizes(writes) the entry in permanent store file.

@param aStreamId stream id which needs to externalized.

@param aSmsMessage reference to sms message which needs to be externalized.

@param aIndexArray refence to array of index which needs to be externalized.

@param aSmsArray refence to array of sms which needs to be externalized.

@internalComponent

*/

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

	{

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

	RStoreWriteStream writestream;