// 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 "UP_STD.H"

 #include <pbe.h>

 EXPORT_C void TStorePagePoolToken::ExternalizeL(RWriteStream& aStream) const

 /** Externalises a TStorePagePoolToken object to a stream.

 @param aStream Stream to which the object should be externalised */

 	{

 	aStream<<iHead;

 	aStream<<iAvail;

 	}

 EXPORT_C void TStorePagePoolToken::InternalizeL(RReadStream& aStream)

 /** Internalises a TStorePagePoolToken object from a stream.

 @param aStream Stream from which the object should be internalised */

 	{

 	aStream>>iHead;

 	aStream>>iAvail;

 	}

 // Class RStorePagePool

 EXPORT_C RStorePagePool::RStorePagePool()

 	: iStore(NULL)

 /** Default constructor. */

 	{}

 EXPORT_C RStorePagePool::RStorePagePool(CPageCache& aCache)

 	: TCachePagePool(aCache),iStore(NULL)

 /** Constructor with a page cache for the pool.

 @param aCache Page cache for the pool */

 	{}

 EXPORT_C RStorePagePool::RStorePagePool(CStreamStore& aStore)

 /** Constructor with a stream store to use for the pool.

 @param aStore Stream store to use for the pool */

 	{

 	Create(aStore);

 	}

 EXPORT_C RStorePagePool::RStorePagePool(CStreamStore& aStore,const TStorePagePoolToken& aToken)

 /** Constructor with a stream store and settings to use for the pool.

 @param aStore Stream store to use for the pool

 @param aToken Stream store pool settings */

 	{

 	Open(aStore,aToken);

 	}

 EXPORT_C void RStorePagePool::Create(CStreamStore& aStore)

 /** Creates a new pool.

 @param aStore Stream store to use for the pool */

 	{

 	iStore=&aStore;

 	iHead=KNullStreamId;

 	iAvail=KNullPageRef;

 	iDirty=EFalse;

 	}

 EXPORT_C void RStorePagePool::Open(CStreamStore& aStore,const TStorePagePoolToken& aToken)

 /** Opens an existing pool.

 @param aStore Stream store for the pool

 @param aToken Pool settings */

 	{

 	iStore=&aStore;

 	iHead=aToken.iHead;

 	iAvail=aToken.iAvail;

 	iDirty=EFalse;

 	}

 EXPORT_C TStorePagePoolToken RStorePagePool::Token() const

 /** Gets an object that encapsulates the page pool settings.   

 That object can then be used to externalise the settings.

 @return Encapsulates the page pool settings */

 	{

 	return TStorePagePoolToken(iHead,iAvail);

 	}

 EXPORT_C void RStorePagePool::Close()

 /** Flushes and purges the page cache and stops using the stream store. */

 	{

 	TCachePagePool::Flush();

 	Release();

 	}

 EXPORT_C TBool RStorePagePool::ReclaimL()

 /** Deletes the first stream that stores reclaimable pages in the store.

 @return True if there are remaining streams (pages), false if there are no 

 more streams */

 	{

 	__ASSERT_DEBUG(iStore!=NULL,Panic(EPageNotOpen));

 	__ASSERT_ALWAYS(iAvail==KNullPageRef,Panic(EPageReclaimAvailable));

 	if (iHead!=KNullStreamId)

 		{

 		RStoreReadStream out;

 		out.OpenLC(*iStore,iHead);

 		TStreamId next;

 		out>>next;

 		CleanupStack::PopAndDestroy();

 		iStore->DeleteL(iHead);

 		iHead=next;

 		MarkDirty();

 		if (next!=KNullStreamId)

 			return ETrue;

 		}

 	return EFalse;

 	}

 EXPORT_C void RStorePagePool::ReclaimAllL()

 /** Deletes all streams in the store. */

 	{

 	while (ReclaimL())

 		;

 	}

 EXPORT_C TPageRef RStorePagePool::ExtendL(const TAny* aPage,TPageReclamation aReclamation)

 //

 // Create a new page.

 //

 	{

 	return StorePagePool::ExtendL(*this,aPage,aReclamation);

 	}

 EXPORT_C void RStorePagePool::WriteL(TPageRef aRef,const TAny* aPage,TPageChange aChange)

 //

 // Write a page to the store.

 //

 	{

 	StorePagePool::WriteL(*this,aRef,aPage,aChange);

 	}

 EXPORT_C void RStorePagePool::ReadL(TPageRef aRef,TAny* aPage)

 //

 // Read from the store into a page.

 //

 	{

 	StorePagePool::ReadL(*this,aRef,aPage);

 	}

 EXPORT_C void RStorePagePool::DoDeleteL(TPageRef aRef)

 //

 // Delete from store.

 //

 	{

 	StorePagePool::DeleteL(*this,aRef);

 	}

 // Class RSecureStorePagePool

 EXPORT_C RSecureStorePagePool::RSecureStorePagePool(const CPBEncryptSet& aKey)

 	: iKey(aKey)

 	{}

 EXPORT_C RSecureStorePagePool::RSecureStorePagePool(CPageCache& aCache, const CPBEncryptSet& aKey)

 	: RStorePagePool(aCache),

 	iKey(aKey)

 	{}

 /** Adds a new page to the pool.

 @param aPage Data for the page

 @param aReclamation Flags that define how allocated pages can be reclaimed

 @return Reference to newly created page */

 EXPORT_C TPageRef RSecureStorePagePool::ExtendL(const TAny* aPage,TPageReclamation aReclamation)

 	{		

 	return StorePagePool::ExtendL(*this,aPage,aReclamation);

 	}

 /** Writes data to a page in the pool.

 @param aRef Reference to the page to which to write

 @param aPage Data to write

 @param aChange Flags that define how a page should be treated when it is unlocked 

 for writing */

 EXPORT_C void RSecureStorePagePool::WriteL(TPageRef aRef,const TAny* aPage,TPageChange aChange)

 	{

 	StorePagePool::WriteL(*this,aRef,aPage,aChange);

 	}

 /** Reads a specified page from the pool.

 @param aRef Reference to page to read

 @param aPage On return, the page data */

 EXPORT_C void RSecureStorePagePool::ReadL(TPageRef aRef,TAny* aPage)

 	{

 	StorePagePool::ReadL(*this,aRef,aPage);

 	}

 /** Deletes a specified page.

 @param aRef Reference to page to delete */

 EXPORT_C void RSecureStorePagePool::DoDeleteL(TPageRef aRef)

 	{

 	StorePagePool::DeleteL(*this,aRef);

 	}

 // Class StorePagePool

 // the implementation of the clever bits to share code between the secure and plain sotre page pools

 const TInt KMaxPageIndex=15;

 inline TInt PageSize(const CPBEncryptionBase* aKey)

 	{

 	return aKey ? aKey->MaxCiphertextLength(KPoolPageSize) : KPoolPageSize;

 	}

 inline TPageRef PageRef(TStreamId anId,TInt anIndex=0)

 	{

 	__ASSERT_DEBUG(anIndex>=0&&anIndex<=KMaxPageIndex,User::Invariant());

 	return TPageRef((anId.Value()<<4)+anIndex);

 	}

 inline TInt PageIndex(TPageRef aRef)

 	{return aRef.Value()&0xf;}

 inline TStreamId StreamId(TPageRef aRef)

 	{return TStreamId(aRef.Value()>>4);}

 inline TStreamPos PagePos(TInt anIndex,TInt aPageSize)

 	{return TStreamPos(sizeof(TStreamId)+(anIndex-1)*aPageSize);}

 void StorePagePool::PadL(RWriteStream& aStream,TInt aLength)

 //

 // zero-pad a stream

 //

 	{

 	TUint8 zero[KPoolPageSize];

 	Mem::FillZ(zero,KPoolPageSize);

 	while ((aLength-=KPoolPageSize)>0)

 		aStream.WriteL(zero,KPoolPageSize);

 	aStream.WriteL(zero,aLength+KPoolPageSize);

 	}

 //

 // Encrypt the page to the stream, padding out to full page size

 void StorePagePool::EncryptL(RWriteStream& aStream,const TAny* aPage,const CPBEncryptionBase& aKey)

 	{

 	REncryptStream encrypt;

 	encrypt.OpenLC(aStream,aKey);

 	encrypt.WriteL((const TUint8*)aPage,KPoolPageSize);

 	encrypt.CommitL();

 	CleanupStack::PopAndDestroy(&encrypt);

 	}

 //

 // Encrypt the page to the stream, padding out to full page size

 //

 void StorePagePool::EncryptNewL(RWriteStream& aStream,const TAny* aPage,const CPBEncryptionBase& aKey)

 	{

 	TStreamPos pos=aStream.Sink()->TellL(MStreamBuf::EWrite);		// remember the start of the data

 	EncryptL(aStream,aPage,aKey);

 	TInt pad=PageSize(&aKey)-(aStream.Sink()->TellL(MStreamBuf::EWrite)-pos);		// bytes written

 	__ASSERT_DEBUG(pad>=0,Panic(EPageCipherTextOverrun));

 	if (pad)

 		PadL(aStream,pad);

 	}

 //

 // Encrypt the page to the stream, padding out to full page size

 //

 void StorePagePool::DecryptL(RReadStream& aStream,TAny* aPage,const CPBEncryptionBase& aKey)

 	{

 	RDecryptStream decrypt;

 	decrypt.OpenLC(aStream,aKey);

 	decrypt.ReadL((TUint8*)aPage,KPoolPageSize);

 	CleanupStack::PopAndDestroy();

 	}

 void StorePagePool::SeekL(MStreamBuf* aBuf,TInt aMark,TPageRef aRef,const CPBEncryptionBase* aKey)

 	{

 	TInt ix=PageIndex(aRef);

 	if (ix)

 		aBuf->SeekL(aMark,PagePos(ix,PageSize(aKey)));

 	}

 TPageRef StorePagePool::ExtendL(RStorePagePool& aPool,const TAny* aPage,TPageReclamation aReclamation,const CPBEncryptionBase* aKey)

 	{

 	__ASSERT_DEBUG(aPool.iStore!=NULL,Panic(EPageNotOpen));

 	TPageRef page;

 	RStoreWriteStream out;

 	if (aReclamation==EPageDeleteOnly)

 		{	// non-reclaimable page

 		page=PageRef(out.CreateLC(*aPool.iStore));

 		}

 	else if (aPool.iAvail!=KNullPageRef)

 		{	// use free page

 		page=aPool.iAvail;

 		out.OpenLC(*aPool.iStore,StreamId(page));

 		MStreamBuf* buf=out.Sink();

 		SeekL(buf,MStreamBuf::ERead|MStreamBuf::EWrite,page,aKey);

 		RReadStream in(buf);

 		in>>aPool.iAvail;

 		aPool.MarkDirty();

 		}

 	else

 		{	// allocate new block, and create free list

 		TStreamId id=out.CreateLC(*aPool.iStore);

 		out<<aPool.iHead;			// block list

 		const TInt pad=PageSize(aKey)-sizeof(TPageRef);

 		page=KNullPageRef;	// free-list terminator

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

 			{

 			out<<page;

 			PadL(out,pad);

 			page=PageRef(id,index);

 			}

 		aPool.MarkDirty();

 		aPool.iHead=id;

 		aPool.iAvail=page;

 		page=PageRef(id,KMaxPageIndex);	// page is written at end

 		}

 	if (aKey)

 		EncryptNewL(out,aPage,*aKey);

 	else

 		out.WriteL((const TUint8*)aPage,KPoolPageSize);

 	out.CommitL();

 	CleanupStack::PopAndDestroy();

 	return page;

 	}

 void StorePagePool::WriteL(RStorePagePool& aPool,TPageRef aRef,const TAny* aPage,TPageChange aChange,const CPBEncryptionBase* aKey)

 	{

 	__ASSERT_DEBUG(aChange>=EPageDirty,Panic(EPageChangeInvalid));

 	__ASSERT_DEBUG(aPool.iStore!=NULL,Panic(EPageNotOpen));

 	RStoreWriteStream out;

 	if (aChange==EPageUpdate)

 		{

 		__ASSERT_DEBUG(PageIndex(aRef)==0,Panic(EPageChangeInvalid));

 		out.ReplaceLC(*aPool.iStore,StreamId(aRef));

 		if (aKey)

 			EncryptNewL(out,aPage,*aKey);

 		else

 			out.WriteL((const TUint8*)aPage,KPoolPageSize);

 		}

 	else

 		{	// re-write the page, no padding req'd

 		out.OpenLC(*aPool.iStore,StreamId(aRef));

 		SeekL(out.Sink(),MStreamBuf::EWrite,aRef,aKey);

 		if (aKey)

 			EncryptL(out,aPage,*aKey);

 		else

 			out.WriteL((const TUint8*)aPage,KPoolPageSize);

 		}

 	out.CommitL();

 	CleanupStack::PopAndDestroy();

 	}

 void StorePagePool::ReadL(RStorePagePool& aPool,TPageRef aRef,TAny* aPage,const CPBEncryptionBase* aKey)

 	{

 	__ASSERT_DEBUG(aPool.iStore!=NULL,Panic(EPageNotOpen));

 	RStoreReadStream in;

 	in.OpenLC(*aPool.iStore,StreamId(aRef));

 	SeekL(in.Source(),MStreamBuf::ERead,aRef,aKey);

 	if (aKey)

 		DecryptL(in,aPage,*aKey);

 	else

 		in.ReadL((TUint8*)aPage,KPoolPageSize);

 	CleanupStack::PopAndDestroy();	// in

 	}

 void StorePagePool::DeleteL(RStorePagePool& aPool,TPageRef aRef,const CPBEncryptionBase* aKey)

 	{

 	aPool.CacheDeleteL(aRef);

 	__ASSERT_DEBUG(aPool.iStore!=NULL,Panic(EPageNotOpen));

 	if (PageIndex(aRef)==0)

 		{	//non-reclaimable

 		aPool.iStore->DeleteL(StreamId(aRef));

 		return;

 		}

 	// add to free list

 	RStoreWriteStream out;

 	out.OpenLC(*aPool.iStore,StreamId(aRef));

 	SeekL(out.Sink(),MStreamBuf::EWrite,aRef,aKey);

 	out<<aPool.iAvail;

 	out.CommitL();

 	CleanupStack::PopAndDestroy();

 	aPool.iAvail=aRef;

 	aPool.MarkDirty();

 	}