/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include <s32file.h>

#include "s32file_private.h"

#include <e32err.h>

#include <fstream>

#include <set>

#include "us_std.h"

#include "filestream.h"

#include "logger.h"

using namespace store_private;

//The offset of the header of a permanent file store.

//Since all permanent file store operations work in their own coordinate system, where physical file offset 32 is

//logical offset 0, KPermanentStoreHeaderOffset is set with -16, which means that the physical file offset is 32 - 16 = 16.

const TInt KPermanentStoreHeaderOffset=-16;

//Permanent file store header length: sizeof(backup TOC ref) + sizeof(handle) + sizeof(TOC ref) + sizeof(crc) = 4 + 4 + 4 + 2 = 14

const TInt KPermanentStoreHeaderLength=14;

//Backup TOC ref length - 4 bytes

const TInt KPermanentStoreBackupLength=4;

const TInt KFileStoreStartOffset=sizeof(TCheckedUid);

const TInt KBaseOffset=KFileStoreStartOffset-KPermanentStoreHeaderOffset;

//

const TInt KMaskHandleHash=0xff000000;

const TInt KHandleInvalid=0x80000000;

const TInt KHandleTocBase=0x40000000;

const TInt KMaskHandleClear=0x30000000;

const TInt KMaskHandleGen=0x0f000000;

const TInt KIncHandleGen=0x01000000;

//

const TInt KMaxHandleIndex=0x00ffffff;

const TInt KMaskHandleIndex=0x00ffffff;

const TInt KSizeHandleIndex=3;

//

const TInt KTocDeltaCap = 64;		//up to 64 entries in a delta TOC

const TInt KTocDeltaMagic = 2;

const TInt KMaxTocDeltaMagic = KMaxTUint16;

const TInt KTocDelta=KHandleInvalid;

//

const TInt KOffsetTocHeader=-12;

const TInt KSizeTocEntry=5;		//base toc entry size is 5 bytes (when stored in the file, 8 bytes when presented in memory)

const TInt KSizeTocDeltaEntry=8;//delta toc entry size is 8 bytes

const TInt KSizeTocDeltaExtra=7;

const TInt KElementsTocBuf=48;

const TInt KBackTocBuf=20*KSizeTocEntry;

const TInt KSizeTocBuf=KElementsTocBuf*KSizeTocEntry;

enum TFrameType16

	{

	EFrameFree16=0x0000,

	EFrameData16=0x4000,

	EFrameDescriptive16=0x8000,

	EFrameContinuation16=0xc000

	};

typedef TUint16 TFrameDes16;

const TInt KSizeFrameDes16=sizeof(TFrameDes16);

const TInt KShiftFrameDes16=1;

//

const TInt KMaskFrame16=0xffff;

const TInt KMaskFrameType16=0xc000;

#if defined(__SMALL_FRAME)

const TInt KMaskFrameLength16=0xf;

const TInt KShiftFrameLength16=4;

#else

const TInt KMaskFrameLength16=0x3fff;

const TInt KShiftFrameLength16=14;

#endif

//

const TInt KFrameOpen16=0;

const TInt KFrameMinLength16=1;

const TInt KFrameMaxLength16=KMaskFrameLength16;

const TInt KFrameFullLength16=KMaskFrameLength16+1;

//

const TInt KFrameNonexistent16=-1;

TUint32 frame2File(TUint32 anOffset)

{

	// The frame offset appears to be to calculated as an offset into

	// a series of maximal length frames.  Each maximal frame can hold

	// 0x4000 bytes of data and has a 2 byte header. Therefore a frame

	// offset of x needs an extra 2 bytes for each maximal frame. The

	// base is the first byte of the payload of the first frame, so we

	// do not need to allow for the header of the first frame.

	//

	// anOffset>>KShiftFrameLength16 gives the number of maximal

	// frames. The left shift multiples by 2 to give minimum space

	// required for frame headers. Adding to the original gives the

	// file offset.

	//

	// This logic is still used even if space for the target frame is

	// really ocupied by a series of smaller frames.

	anOffset += (anOffset>>KShiftFrameLength16<<KShiftFrameDes16);

	// Add 32 to allow for file header

	anOffset += KBaseOffset;

	return anOffset;

}

TUint32 file2Frame(TUint32 aFileOffset)

{

	// subtract 32 to allow for file header

	aFileOffset -= KBaseOffset;

	// File offset is to the first byte of payload of a stream. We

	// need to remove the 2 byte frame header for the (theoretical)

	// maximal length frames before it.

	// Calculate the number of (theoretical) maximal length frames before the file position

	// n = aFileOffset/0x4002

	TInt n=aFileOffset/(KFrameFullLength16+KSizeFrameDes16);

	// Subtract the frame header length for each maximal frame

	aFileOffset -= n<<KShiftFrameDes16;

	return aFileOffset;

}

//TPermanentStoreHeader class.

//

//Represents the data kept in the permanent store file header.

//Data members:

// - iBackup - "backup TOC reference", 32-bits integer, which keeps the 31-bit file offset of the backup TOC.

//             Plays important role in the "store commit" procedure.

//             The LSB is a "dirty" bit. If during the store opening phase the dirty bit is found to be set,

//             then it means - the previous "store commit" operation has not been completed successfully and

//             the backup TOC shall be used instead of the TOC;

// - iHandle - 32-bit stream handle (MSB - invalid/deleted, 3 bits - unused, 4 bits - generation counter, 24 bits - stream handle).

//             Plays important role in the "stream relocation" procedure during store compaction.

//             iHandle keeps the handle of the stream being relocated, so if the commit phase fails, the original stream entry

//             can be restored at the moment when the store is reopened;

// - iRef    - Current "TOC reference". Represents a file offset, where the current TOC is;

// - iCrc    - 16-bit CRC, protecting iBackup, iHandle, iRef;

class TPermanentStoreHeader

	{

public:

	TPermanentStoreHeader() : iBackup(0), iHandle(0), iRef(0), iCrc(0) {}

	TUint8* Ptr();

	const TUint8* Ptr() const;

	TBool IsValid() const;

//

	TPermanentStoreHeader(TInt aToc);

	TPermanentStoreHeader(TInt aBackupToc,TInt aHandle,TInt aReference);

//

	TBool IsDirty() const;

	void MarkDirty();

	void SetBackupToc(TInt aBackupToc);

	TInt BackupToc() const;

//

	TInt Handle() const;

	TInt Reference() const;

private:

	void Set(TInt aBackupToc,TInt aHandle,TInt aReference);

private:

	TUint32 iBackup;

	TInt32 iHandle;

	TInt32 iRef;

	TUint16 iCrc;

public:

	// Changes for port

	void InternalizeL(RReadStream &aStream);

	void ExternalizeL(RWriteStream &aStream) const;

	};

// Class TPermanentStoreHeader

TUint8* TPermanentStoreHeader::Ptr()

	{return REINTERPRET_CAST(TUint8*,&iBackup);}

const TUint8* TPermanentStoreHeader::Ptr() const

	{return REINTERPRET_CAST(const TUint8*,&iBackup);}

TPermanentStoreHeader::TPermanentStoreHeader(TInt aToc)

{Set(aToc,0,aToc);}

TPermanentStoreHeader::TPermanentStoreHeader(TInt aBackupToc,TInt aHandle,TInt aReference)

{

	__ASSERT_DEBUG(aHandle!=0,User::Invariant());

	Set(aBackupToc,aHandle,aReference);

}

TBool TPermanentStoreHeader::IsDirty() const

{

	return iBackup&0x1;

}

void TPermanentStoreHeader::MarkDirty()

{

	iBackup|=0x1;

}

void TPermanentStoreHeader::SetBackupToc(TInt aBackupToc)

{

	__ASSERT_DEBUG(aBackupToc>=0,User::Invariant());

	iBackup=TUint32(aBackupToc)<<1;

}

TInt TPermanentStoreHeader::BackupToc() const

{

	return iBackup>>1;

}

TInt TPermanentStoreHeader::Handle() const

{

	return iHandle;

}

TInt TPermanentStoreHeader::Reference() const

{

	return iRef;

}

TBool TPermanentStoreHeader::IsValid() const

{

	if (IsDirty())

		return EFalse;

	TUint16 crc=0;

	Mem::Crc(crc,Ptr(),_FOFF(TPermanentStoreHeader,iCrc));

	return crc==iCrc;

}

//Sets the "backup TOC ref", "handle" and "TOC ref" in current TPermanentStoreHeader object.

//16-bit CRC is calculated, based on the values of the input parameters, and stored together with them in the 

//TPermanentStoreHeader object.

void TPermanentStoreHeader::Set(TInt aBackupToc,TInt aHandle,TInt aReference)

	{

	iBackup=TUint32(aBackupToc)<<1;

	iHandle=aHandle;

	iRef=aReference;

	iCrc=0;

	Mem::Crc(iCrc,Ptr(),_FOFF(TPermanentStoreHeader,iCrc));

	__ASSERT_DEBUG(IsValid(),User::Invariant());

	}

void TPermanentStoreHeader::InternalizeL(RReadStream &aStream)

{

	aStream >> iBackup;

	aStream >> iHandle;

	aStream >> iRef;

	aStream >> iCrc;

}

void TPermanentStoreHeader::ExternalizeL(RWriteStream &aStream) const

{

	aStream << iBackup;

	aStream << iHandle;

	aStream << iRef;

	aStream << iCrc;

}

struct TocHeader

	{

	TInt32 iPrimary;

	TInt32 iAvail;

	TUint32 iCount;

	void ExternalizeL(RWriteStream &aStream) const;

	void InternalizeL(RReadStream &aStream);

	};

void TocHeader::ExternalizeL(RWriteStream &aStream) const

{

	aStream << iPrimary;

	aStream << iAvail;

	aStream << iCount;

}

void TocHeader::InternalizeL(RReadStream &aStream)

{

	aStream >> iPrimary;

	aStream >> iAvail;

	aStream >> iCount;

}

struct STocEntry

	{

	TInt32 handle;

	TInt32 ref;

	void ExternalizeL(RWriteStream &aStream) const;

	void InternalizeL(RReadStream &aStream);

	};

void STocEntry::ExternalizeL(RWriteStream &aStream) const

{

	aStream.WriteL((TUint8*)&handle + KSizeHandleIndex, KSizeTocEntry);

}

void STocEntry::InternalizeL(RReadStream &aStream)

{

	aStream.ReadL((TUint8*)&handle + KSizeHandleIndex, KSizeTocEntry);

}

CStreamStore::~CStreamStore()

{

}

TStreamId CPersistentStore::Root()

{

	return iRoot;

}

void CPersistentStore::SetRootL(TStreamId anId)

{

	iRoot = anId;

}

void CFileStore::SetTypeL(const TUidType& aType)

{

	if(aType != KPermanentFileStoreLayoutUid) FatalError();

}

CFileStore *CPermanentFileStore::ReplaceLC(RFs &aFs, const TDesC &aName, TUint aFileMode)

{

	(void) aFs;

	return new CPermanentFileStore(aName, aFileMode);

}

CPermanentFileStore* CPermanentFileStore::OpenLC(RFs& aFs,const TDesC& aName,TUint aFileMode)

{

	(void) aFs;

	CPermanentFileStore *pfs = new CPermanentFileStore(aName, aFileMode);

	pfs->ReadInData();

	return pfs;

}

CPermanentFileStore::CPermanentFileStore(const TDesC& aName,TUint aFileMode)

	: iWritable(false), iFileIn(), iFileOut(), iLastStreamIdCreated(0), 

	  iStreams()

{

	TBuf8<KMaxName> utf8Name;

	utf8Name.Copy(aName);

	std::string name((const char *)utf8Name.Ptr(), utf8Name.Length());

	if(aFileMode & EFileWrite)

		{

		iFileOut.reset(new FileWriteStream(name));

		iWritable = true;

		}

	else

		{

		iFileIn.reset(new FileReadStream(name));

		}

}

CPermanentFileStore::~CPermanentFileStore()

{

	while(!iStreams.empty())

		{

		MemStreamBuf *p = (*iStreams.begin()).second;

		iStreams.erase(iStreams.begin());

		delete p;

		}

}

MemStreamBuf *CPermanentFileStore::CreateStoreWriteStream()

{

	TStreamId id = ++iLastStreamIdCreated;

	MemStreamBuf *handler = new MemStreamBuf(*this, id);

	MemStreamBufPtrMap::value_type value(id, handler);

	std::pair<MemStreamBufPtrMap::iterator, bool> ret = iStreams.insert(value);

	if(!ret.second)

		{

		// Insert failed

		FatalError();

		}

	return handler;

}

MemStreamBuf *CPermanentFileStore::CreateStoreReadStream(TStreamId aId) const

{

	MemStreamBufPtrMap::const_iterator it = iStreams.find(TUint32(aId));

	if(it == iStreams.end())

		{

		// Lookup failed

		dbg << Log::Indent() << "StreamId 0x" << aId << " does not exist in store!" << Log::Endl();

		FatalError();

		}

	return (*it).second;

}

bool CPermanentFileStore::Writable() const

{

	return iWritable;

}

void CPermanentFileStore::CommitL()

{

	if(!iWritable) FatalError();	

	TCheckedUid id(KPermanentFileStoreLayoutUid);

	*iFileOut << id;

	// Write an empty header, we will correct the fields later

	TPermanentStoreHeader tmpheader(0);

	*iFileOut << tmpheader;

	//

	// Now write out the streams

	//

	std::vector<TUint> streamOffsets;

	for(MemStreamBufPtrMap::const_iterator streamIt = iStreams.begin();

		streamIt != iStreams.end(); 

		++streamIt)

		{

		const MemStreamBuf::StreamData &streamData((*streamIt).second->GetData());

		// Record the offset to the first byte of the payload for use in the TOC

		streamOffsets.push_back(TUint32(iFileOut->iSnk->TellL(MStreamBuf::EWrite))+KSizeFrameDes16);

		TUint32 dataAvailable = streamData.size();

		MemStreamBuf::StreamData::const_iterator dataIt = streamData.begin();

		TUint32 currentType = EFrameData16;

		while(dataAvailable)

			{

			TUint32 toWrite;

			TFrameDes16 frame;

			TUint32 fileOffset = TUint32(iFileOut->iSnk->TellL(MStreamBuf::EWrite))+KSizeFrameDes16;

			TUint32 frameOffset = file2Frame(fileOffset);

			TUint32 nextAnchor = ((frameOffset + KFrameFullLength16) & ~KMaskFrameLength16);

			if(dataAvailable >= (nextAnchor-frameOffset))

				{

				// We have enough data to write an "Open" frame to

				// take the frame offset up to the next multiple of

				// 0x4000

				toWrite = (nextAnchor-frameOffset);

				frame = currentType | KFrameOpen16;

				}

			else

				{

				// Write a normal frame

				toWrite = (dataAvailable < TUint32(KMaskFrameLength16)) ? (dataAvailable) : (KMaskFrameLength16);

				frame = currentType | toWrite;

				}

			// Write frame

			*iFileOut << frame;

			// Write payload

			while(toWrite--)

				{

				*iFileOut << *dataIt;

				++dataIt;

				--dataAvailable;

				}

			// Set type of next frame to continuation

			currentType = EFrameContinuation16;

			}

		}

	//

	// Now write the TOC

	//

	TInt tocLength = sizeof(TocHeader) + (iStreams.size() * KSizeTocEntry);

	// Check toc frame length is not too long

	if(tocLength > KMaskFrameLength16)

		{

		FatalError();

		}

	// Write TOC frame