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

//

#include <s32file.h>

#include "UT_STD.H"

//The default media block size, used in the computations, if the file system guarantees atomic "block write" file operations.

const TInt KDefaultMediaBlockSize = 512;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              TPermanentStoreHeader               /////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Returns false, if:

// - the dirty bit is set (indicates commit phase #2 or #3 is not complete);

// - the CRC check fails ("backup TOC ref", "handle" and "TOC ref" are protected by 16-bit CRC in the permanent store file header);

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());

	}

const TInt KTocGranularity=12;

struct STocEntry

	{

	TInt32 handle;

	TInt32 ref;

	};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////              CPermanentStoreToc               ////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

TInt CPermanentStoreToc::TEntry::Compare(const TEntry& aLeft, const TEntry& aRight)

//

// Ordering for Stream handles, return <0,0,>0 depending on comparison

// The index part of the handle is only 24 bits, so just subtract the handles for result

//

	{

	return (aLeft.handle&KMaskHandleIndex) - (aRight.handle&KMaskHandleIndex);

	}

CPermanentStoreToc* CPermanentStoreToc::NewL(TStreamPos aBase,TStreamExchange& aHost,TInt aToc,TInt aBaseReloc)

	{

	CPermanentStoreToc* table=new(ELeave) CPermanentStoreToc(aBase,aHost);

	CleanupStack::PushL(table);

	table->ConstructL(aToc,aBaseReloc);

	CleanupStack::Pop();

	return table;

	}

TBool CPermanentStoreToc::IsDelta() const

//

// Report whether the current TOC should be written as a delta, or a base TOC

//

	{

	TInt delta = iEntries.Count();

	if (delta >= KTocDeltaCap)

		return EFalse;

	TInt magic = iMagic + delta;

	if (magic > KMaxTocDeltaMagic)

		return EFalse;

	return magic*KSizeTocDeltaEntry <= iCount*KSizeTocEntry - KSizeTocDeltaExtra;

	}

void CPermanentStoreToc::Move(TInt aToc,TInt anExtent)

//

// Final stage of compaction, update to address new TOC

//

	{

	__ASSERT_DEBUG(anExtent<=iOff&&anExtent>=aToc&&anExtent-(aToc+KOffsetTocHeader)==iExt-iOff,User::Invariant());

	if (!HasDelta())

		{

		// Base-toc only, update the base toc position as well

		TInt window=iWindow-iTocExt;

		iTocOff=aToc+KOffsetTocHeader;

		iTocExt=anExtent;

		iWindow=anExtent+window;

		}

	iOff = aToc+KOffsetTocHeader;

	iExt = anExtent;

	}

TInt CPermanentStoreToc::RealizeL(TInt aPrimary,TInt anExtent) const

	{

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

	RFrame16Buf buf(Base());

	buf.PushL();

	const TBool delta = IsDelta();

	aPrimary &= KMaskStreamIdValue;

	if (delta)

		aPrimary |= KTocDelta;

	STocHead h;

	h.primary=TInt32(aPrimary);

	h.avail=TInt32(iAvail);

	h.count=TUint32(iCount);

//

	TInt off;

	if (delta)

		off=DeltaL(buf,anExtent,h);

	else

		off=RewriteL(buf,anExtent,h);

//

	buf.SynchL();

	CleanupStack::PopAndDestroy(&buf);

	return off-KOffsetTocHeader;

	}

void CPermanentStoreToc::Adopt(TInt aToc,TInt aPrimary)

//

// Final stage of Commit - all file changes have been successful

// Record the new Toc location and reset the changed flag

//

	{

	__ASSERT_DEBUG(aToc+KOffsetTocHeader>=iExt,User::Invariant());

	if (IsDelta())

		{

		// Adjust the TOC-delta location

		TInt c = iEntries.Count();

		iOff=aToc+KOffsetTocHeader;

		iExt=aToc + KSizeTocDeltaExtra + KSizeTocDeltaEntry*c;

		if (c > KTocDeltaMagic)

			iMagic += c - KTocDeltaMagic;

		}

	else

		{

		// Adjust all the TOC data and reset the delta-set

		TInt window = iTocOff>=0 ? iWindow-iTocOff : -KOffsetTocHeader;

		iTocOff=iOff=aToc+KOffsetTocHeader;

		iTocExt=iExt=aToc+KSizeTocEntry*iCount;

		iWindow = iTocOff + window;

		iEntries.Reset();

		iMagic = 0;

		}

	iPrimary=aPrimary;

	__ASSERT_DEBUG(!IsVirtual(),User::Invariant());

	}

TInt CPermanentStoreToc::AllocL(TInt anOffset)

	{

	TEntry& entry=DoAllocL();

	entry.ref=anOffset;

	return entry.handle;

	}

TInt CPermanentStoreToc::AllocL()

	{

	TEntry& entry=DoAllocL();

	entry.ref=KFrameNonexistent16;

	return entry.handle|=KHandleInvalid;

	}

void CPermanentStoreToc::Cancel(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle<0&&IsVirtual(),User::Invariant());

	TEntry* entry=Entry(aHandle);

	__ASSERT_DEBUG((entry!=NULL) && (entry->handle==aHandle),User::Invariant());

	entry->ref=iAvail;

	iAvail=aHandle;

	}

void CPermanentStoreToc::FreeL(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	TEntry& entry=FetchL(aHandle);

	aHandle|=KHandleInvalid;

	entry.handle=aHandle;

	entry.ref=iAvail;

	iAvail=aHandle;

	Changed();

	}

TInt CPermanentStoreToc::AtL(TInt aHandle) const

	{

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	// check the delta table

	const TEntry* entry=Entry(aHandle);

	if (entry!=NULL )

		{

		// if there is an entry in the delta table, but its

		// not an exact match leave with KErrNotFound

		// This happens when the delta indicates it's been deleted

		if (entry->handle!=aHandle)

			User::Leave(KErrNotFound);

		return entry->ref;

		}

//

	// if it's not in the delta table check the base TOC

	return DoAtL(aHandle);

	}

void CPermanentStoreToc::PutL(TInt aHandle, TInt anOffset, TPut aCheck)

//

// Used by compaction to update a single stream reference IN-PLACE in the TOC

// We need to check in which TOC to make the update

//

	{

	__ASSERT_DEBUG(!IsVirtual(),User::Invariant());

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	__ASSERT_DEBUG(aHandle!=KHandleTocBase || HasDelta(),User::Invariant());

	if (aHandle == KHandleTocBase)

		{

		// update the TOC-base link

		PutTocL(anOffset - KOffsetTocHeader, aCheck);

		if (iTocOff != anOffset)

			{

			TInt size = iTocExt - iTocOff;

			TInt window = iWindow - iTocOff;

			iTocOff = anOffset;

			iTocExt = anOffset + size;

			iWindow = anOffset + window;

			}

		return;

		}

	TEntry e;

	e.handle=aHandle;

	TInt i;

	if (iEntries.FindInOrder(e,i,&TEntry::Compare)==0)

		{

		// update TOC-delta entry

		TEntry& entry=iEntries[i];

		if (entry.handle==aHandle && entry.ref != anOffset)

			{

			PutDeltaL(i,aHandle,anOffset);

			entry.ref=anOffset;

			}

		return;

		}

	// update TOC-base entry

	if (aCheck==EWrite || DoAtL(aHandle)!=anOffset)

		PutBaseL(aHandle,anOffset);

	}

TInt CPermanentStoreToc::GetL(TInt aHandle)

	{

	__ASSERT_DEBUG(aHandle>0,User::Invariant());

	TEntry& entry=FetchL(aHandle);

	return entry.ref;

	}

TInt CPermanentStoreToc::Set(TInt aHandle,TInt anOffset)

	{

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

	TEntry* entry=Entry(aHandle);

	__ASSERT_DEBUG((entry!=NULL) && (entry->handle==aHandle),User::Invariant());

	aHandle&=KMaskStreamIdValue;

	entry->handle=aHandle;

	entry->ref=anOffset;

	Changed();

	return aHandle;

	}

CPermanentStoreToc::CPermanentStoreToc(TStreamPos aBase,TStreamExchange& aHost)

	: /*iPrimary(0),iAvail(0),iCount(0),*/iEntries(KTocGranularity),

		iBase(aBase),iHost(&aHost),iOff(KFrameNonexistent16)/*,iExt(0)*/,

		iTocOff(KFrameNonexistent16)/*,iTocExt(0),iWindow(0)*/

	{}

CPermanentStoreToc::~CPermanentStoreToc()

	{

	iEntries.Close();

	}

void CPermanentStoreToc::ConstructL(TInt aToc,TInt aBaseReloc)

//

// Read and validate the TOC header at aToc.

// aBaseReloc may contain a relocated TOC-base offset, which should override the one in a TOC-delta

//

	{

	if (aToc==0)

		return;

	__ASSERT_DEBUG(aToc>0&&iEntries.Count()==0,User::Invariant());

	RFrame16Buf buf(Base());

	aToc+=KOffsetTocHeader;

	buf.OpenL(Host(),aToc,EFrameDescriptive16|buf.ERead);

	buf.PushL();

	RReadStream stream(&buf);

	STocHead h;

	stream.ReadL((TUint8*)&h,sizeof(STocHead)); // platform dependency

	if ((h.primary&~(KMaskStreamIdValue|static_cast<TUint>(KTocDelta)))!=0||

		h.avail>0||(h.avail&KMaskHandleClear)!=0||(h.count&~KMaskHandleIndex)!=0)

		__LEAVE(KErrCorrupt);

//

	iPrimary=TInt(h.primary) & ~KTocDelta;

	iAvail=TInt(h.avail);

	iCount=TInt(h.count);

	iOff = aToc;

//

	if (h.primary & KTocDelta)

		{

		// This is a TOC-delta

		aToc = InternalizeL(stream, aBaseReloc) + KOffsetTocHeader;

		// Now locate and validate the base TOC

		buf.Release();

		buf.OpenL(Host(),aToc,EFrameDescriptive16|buf.ERead);

		stream.ReadL((TUint8*)&h,sizeof(STocHead)); // platform dependency

		if ((h.primary&~KMaskStreamIdValue)!=0||(h.count&~KMaskHandleIndex)!=0||

			h.avail>0||(h.avail&KMaskHandleClear)!=0||TInt(h.count)>iCount)

			__LEAVE(KErrCorrupt);

		}

	TInt size = KSizeTocEntry*TInt(h.count);

// Eagerly load the first few TOC entries into the cache

// This is good as it almost certainly lies in the file buffer already

	if (size>0)

		stream.ReadL(&iBuf[0],Min(size,TInt(KSizeTocBuf)));

	size-=KOffsetTocHeader;

	if (buf.SizeL()!=size)

		__LEAVE(KErrCorrupt);

	iTocOff=aToc;

	iWindow=aToc-KOffsetTocHeader;

	iTocExt=aToc+size;

	if (iExt == 0)

		iExt = iTocExt;		// set extent for non-delta TOC

//

	CleanupStack::PopAndDestroy(&buf);

	}

TInt CPermanentStoreToc::InternalizeL(RReadStream& aIn, TInt aBaseReloc)

//

// Load and validate the delta-toc table

//

	{

	TInt tocoff = aIn.ReadInt32L();

	if (aBaseReloc != KFrameNonexistent16)

		tocoff = aBaseReloc - KOffsetTocHeader;

	if (tocoff<0||tocoff>=iOff)

		__LEAVE(KErrCorrupt);

	iMagic = aIn.ReadUint16L();

	if (!IsDelta())

		__LEAVE(KErrCorrupt);

	TInt n = aIn.ReadUint8L();

	TInt size = -KOffsetTocHeader + KSizeTocDeltaExtra + KSizeTocDeltaEntry * n;

	if (aIn.Source()->SizeL()!=size)

		__LEAVE(KErrCorrupt);

	iExt = iOff + size;

	TInt last = 0;

	while (--n >= 0)

		{

		STocEntry e;

		aIn.ReadL((TUint8*)&e,KSizeTocDeltaEntry);	// platform dependency

		if ((e.handle&KMaskHandleClear)!=0||e.handle>=0&&(e.ref<KFrameNonexistent16)||

			e.handle<0&&(e.ref>0||(e.ref&KMaskHandleClear)!=0))

			__LEAVE(KErrCorrupt);

		TInt i = e.handle&KMaskHandleIndex;

		if (i <= last || i > iCount)

			__LEAVE(KErrCorrupt);

		last = i;

		TEntry entry;

		entry.handle = TInt(e.handle);

		entry.ref = TInt(e.ref);

		User::LeaveIfError(iEntries.Append(entry));

		}

	return tocoff;

	}

TInt CPermanentStoreToc::DeltaL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const

//

// Write the TOC-delta

//

	{

	TInt off=aBuf.ExtendL(Host(),aExtent,EFrameDescriptive16|aBuf.EWrite);

	RWriteStream out(&aBuf);

	out.WriteL((TUint8*)&aHead,sizeof(STocHead)); // platform dependency

	out.WriteInt32L(iTocOff - KOffsetTocHeader);

	TInt n = iEntries.Count();

	TInt magic = iMagic;

	if (n > KTocDeltaMagic)

		magic += n - KTocDeltaMagic;

	__ASSERT_DEBUG(magic <= KMaxTocDeltaMagic,User::Invariant());

	__ASSERT_DEBUG(n <= (TInt)KMaxTUint8, User::Invariant());

	out.WriteUint16L(magic);

	out.WriteUint8L(n);

	for (int i = 0; i < n; ++i)

		{

		const TEntry& entry = iEntries[i];

		STocEntry e;

		e.handle=TInt32(entry.handle);

		e.ref=TInt32(entry.ref);

		out.WriteL((TUint8*)&e,KSizeTocDeltaEntry); // platform dependency

		}

	return off;

	}

TInt CPermanentStoreToc::RewriteL(RFrame16Buf& aBuf,TInt aExtent,const STocHead& aHead) const

//

// Write the TOC-base

//

	{

	const TInt KElementsRewrite=304;

	const TInt KSizeRewriteBuf=KElementsRewrite*KSizeTocEntry;

	TUint8 toc[KSizeRewriteBuf];

	RFrame16Buf buf(Base());

	buf.PushL();

	TInt oldsize = 0;

	TInt window = 0;

	if (iTocOff>=0)

		{

		oldsize = iTocExt-iTocOff+KOffsetTocHeader;

		window = iWindow + KOffsetTocHeader - iTocOff;

		if (oldsize <= Min(KSizeTocBuf,KSizeRewriteBuf) && window == 0)

			{

			// the old TOC is already in the toc-base cache, no need to read it

			Mem::Copy(&toc[0],&iBuf[0],oldsize);

			oldsize = 0;	// this prevents the read request

			}

		else

			{

			buf.Set(Host(),iTocOff,iTocExt,EFrameDescriptive16|buf.ERead);

			buf.SeekL(buf.ERead,TStreamPos(-KOffsetTocHeader));

			}

		}

	RReadStream in(&buf);

	// defer the initialisation of the write in roder to improve file buffering performance

	RWriteStream out(&aBuf);

	TInt off=-1;

	TInt size=iCount*KSizeTocEntry;

	for (TInt base=0,delta=0;base<size;base+=KSizeRewriteBuf)

		{

		// fill buffer with old TOC data

		if (base < oldsize)

			in.ReadL(&toc[0],Min(KSizeRewriteBuf,oldsize-base));

		// apply changes to this block

		for (TInt n=iEntries.Count();delta<n;++delta)

			{

			const TEntry& entry=iEntries[delta];

			TInt pos = (entry.handle&KMaskHandleIndex)*KSizeTocEntry - KSizeTocEntry - base;

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

			if (pos>=KSizeRewriteBuf)

				break;

			STocEntry e;

			e.handle=TInt32(entry.handle);

			e.ref=TInt32(entry.ref);

			Mem::Copy(&toc[pos],(const TUint8*)&e+KSizeHandleIndex,KSizeTocEntry);

			pos += base - window;

			if (TUint(pos) < TUint(KSizeTocBuf))

				Mem::Copy(MUTABLE_CAST(TUint8*,&iBuf[pos]),(const TUint8*)&e+KSizeHandleIndex,KSizeTocEntry);

			}

		// write buffer to file

		if (off == -1)

			{

			// initialise writing

			off=aBuf.ExtendL(Host(),aExtent,EFrameDescriptive16|aBuf.EWrite);

			out.WriteL((TUint8*)&aHead,sizeof(STocHead)); // platform dependency

			}

		out.WriteL(&toc[0],Min(KSizeRewriteBuf,size-base));

		}

//

	CleanupStack::PopAndDestroy(&buf);

	return off;

	}

CPermanentStoreToc::TEntry* CPermanentStoreToc::Entry(TInt aHandle)

	{

	TEntry e;

	e.handle=aHandle;

	TInt i;

	if (iEntries.FindInOrder(e,i,&TEntry::Compare)!=0)

		return NULL;

//

	TEntry& entry=iEntries[i];

	// allow entry to return a pointer even if not an exact match

	return &entry;

	}

CPermanentStoreToc::TEntry& CPermanentStoreToc::FetchL(TInt aHandle)

	{

	TEntry e;

	e.handle=aHandle;

	TInt i;

	if (iEntries.FindInOrder(e,i,&TEntry::Compare)!=0)

		{

		e.ref=DoAtL(aHandle);

		User::LeaveIfError(iEntries.Insert(e,i));

		}

	TEntry& entry=iEntries[i];

	if (entry.handle!=aHandle)

		__LEAVE(KErrNotFound);

//

	return entry;

	}

CPermanentStoreToc::TEntry& CPermanentStoreToc::DoAllocL()

	{

	TInt handle=iAvail;

	TEntry* entry;

	if (handle==0)

		{