// Copyright (c) 2001-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 <e32std.h>

#include <e32std_private.h>

#include "sr_rofs.h"

#include <rofs.h>

void CRofs::Panic( TPanic aPanic )

	{

	_LIT( KCategory, "ROFSFSY" );

	User::Panic( KCategory, aPanic );

	}

#ifdef _USE_TRUE_LRU_CACHE

//***********************************************************

//* Data Read Cache for Rofs

//***********************************************************

TCacheSegment::TCacheSegment()

//

// Constructor

//

	: iPos(-1)

	{}

void TCacheSegment::Set(TInt aPos)

//

// Set the diskPos of the data cached

//

	{

	iPos=aPos;

	}

//***********************************************************

CRofsLruCache::CRofsLruCache(CRofsMountCB* aMount, TInt64 aMediaSize)

//

// Least recently used data cache

//

	: iQue(_FOFF(TCacheSegment,iLink)), iMediaSize(aMediaSize)

	{

	iMount=aMount;

	__PRINT(_L("CLruCache::CLruCache()"));

	}

CRofsLruCache::~CRofsLruCache()

//

// Free all data segments

//

	{

	__PRINT(_L("CLruCache::~CLruCache()"));

	TDblQueIter<TCacheSegment> iter(iQue);

	while((TCacheSegment*)iter)

		{

		User::Free(iter++);

		}

	}

TUint8* CRofsLruCache::Find(TInt aPos, TInt aLength)

//

// Find aPos in the cache or return NULL

//

	{

	__PRINT(_L("CLruCache::Find()"));

	TDblQueIter<TCacheSegment> iter(iQue);

	TCacheSegment* data;

	while((data=iter++)!=NULL)		//need to do a range check here

		{

		if(data->iPos < 0)

			continue;

		const TInt KEndOfSegment= data->iPos+ KSizeOfSegment;

		if(data->iPos <= aPos && (KEndOfSegment >=aPos))

			{

			if((aPos+aLength) > (KEndOfSegment))

				{

				data->iLink.Deque();

				iQue.AddLast(*data);

				return(NULL);

				}

			if(!iQue.IsFirst(data)) 

				{

				data->iLink.Deque(); 

				iQue.AddFirst(*data); 

				}

			return(&data->Data()[aPos-data->iPos]);

			}

		}

	// If we got here, it means that we don't have it in cache at all 

	return(NULL);

	}

TUint8* CRofsLruCache::ReadL(TInt aPos, TInt aLength)

//

// Find aPos in the cache or read the data

//

	{

	// Remember for Big size Nand the size of page can increase to 2K. Need to add this feature?

	__PRINT(_L("CLruCache::ReadL()"));

	// Search the cache 

	TUint8* res=Find(aPos, aLength);

	if (res)

		return(res); 

	// Didn't find in the cache, read data from media 	 

	// Align to page boundaries

	TInt pagePos = aPos & ~(KPageSize-1);

	// Read from media

	// Buffer to accomodate two page of data. 

	// We won't cache any read bigger than one page

	// Check if we have any segment available

	TCacheSegment* seg= iQue.Last();

	seg->iLink.Deque();

	seg->Set(pagePos);

	iQue.AddFirst(*seg);

	// ensure we don't read past end of media

	TInt cacheLen = (TInt) Min(iMediaSize -  pagePos, KSizeOfSegment);

	TPtr8 dataBuf((seg->Data()), cacheLen);

	TInt ret = iMount->LocalDrive()->Read(pagePos,cacheLen,dataBuf);

	if (ret!=KErrNone)

		{

		User::Leave(ret);

		}

	return(&dataBuf[aPos & (KPageSize-1)]);

	}

CRofsLruCache* CRofsLruCache::New(TInt aSegmentSize, CRofsMountCB* aMount, TInt64 aMediaSize)

//

// Create an LruList and one segment

//

	{

	__PRINT(_L("CRofsLruCache::New()"));

	CRofsLruCache* lru=new CRofsLruCache(aMount, aMediaSize);

	if (lru==NULL)

		return(NULL);

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

		{

		TCacheSegment* seg=(TCacheSegment*)User::Alloc(aSegmentSize+sizeof(TCacheSegment));

		if (seg==NULL)

			{

			delete lru;

			return(NULL);

			}

		Mem::FillZ(seg,aSegmentSize+sizeof(TCacheSegment));

		*seg=TCacheSegment();

		lru->iQue.AddFirst(*seg);

		}

	return(lru);

	}

//***********************************************************

//* Mount object

//***********************************************************

void CRofsMountCB::CacheReadL(TInt aPos, TInt aLength,const TAny* aDes,TInt anOffset, const RMessagePtr2& aMessage) const

//

//	Do a cached read if possible else read from media and insert to cache

//

	{

	__PRINT2(_L("CRofsMountCB::CacheReadL TAny* Pos 0x%x, Len %d"),aPos,aLength);

	// Don't cache anything more than a page long or if readinf into a file server cache buffer!

	if (((KSizeOfSegment/2) < aLength) || (aMessage.Handle() == KLocalMessageHandle))

		{

		TInt ret = LocalDrive()->Read(aPos,aLength,aDes, aMessage.Handle(), anOffset);

		if (ret!=KErrNone)

			{

			User::Leave(ret);

			}

		}

	else

		{

		TUint8* data =iDataCache->ReadL(aPos, aLength);	//added length to enable cache to fill in the blanks

		TPtrC8 buf(data,aLength);			//return buffer

		aMessage.WriteL(0,buf,anOffset);

		}

	}

#endif

CRofsMountCB::CRofsMountCB()

//

// Constructor

//

	{

	}

void CRofsMountCB::Dismounted()

//

// Dummy implementation of pure virtual function

//

	{}

void CRofsMountCB::MountL(TBool /*aForceMount*/)

//

// Mount a media. 

// Only allowed to leave with KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.

//

	{

	// create the local drive

	TInt r=CreateLocalDrive(GetLocalDrive(Drive().DriveNumber()));

	User::LeaveIfError(r);

	iUniqueID=0;

	TLocalDriveCapsV2Buf caps;

	User::LeaveIfError(LocalDrive()->Caps(caps));

	iMediaSize = caps().iSize;

	// Read ROFS image header

	r = LocalDrive()->Read( 0, sizeof(TRofsHeader), iHeader );

	__PRINT1(_L("CRofsMountCB::MountL, Reading Header %d"), r);

	if( KErrNone != r )

		{

		User::Leave( KErrNotReady );

		}

	r = CheckHeader();

	__PRINT1(_L("CRofsMountCB::MountL, Check Header %d"), r);

	User::LeaveIfError( r );

	r=CheckExtension();

	__PRINT1(_L("CRofsMountCB::MountL, Check Extension %d"), r);

	if(r!=KErrNone && r!=KErrNotFound)

		User::Leave(r);

	//

	// Construct the directory cache

	//

	iDirectoryCache = new(ELeave) CDirectoryCache( *this, *LocalDrive(), iHeader() );

	iDirectoryCache->ConstructL();

#ifdef _USE_TRUE_LRU_CACHE

	//

	// Construct the data cache

	//

	iDataCache = CRofsLruCache::New(KSizeOfSegment,this, iMediaSize);

	if(!iDataCache)

		User::Leave(KErrNoMemory);

#endif

	_LIT( KVolumeName, "Rofs" );

	SetVolumeName( TPtrC(KVolumeName).AllocL() );

	__PRINT(_L("CRofsMountCB::MountL, End of Mount"));

	}

LOCAL_D TBool IsOverlapping( TUint aBase1, TUint aSize1, TUint aBase2, TUint aSize2 )

//

//	Check files and directories are not overlapping

//

	{

	TUint end1 = aBase1 + aSize1 - 1;

	TUint end2 = aBase2 + aSize2 -1;

	if( aBase1 == aBase2 || end1 < aBase1 || end2 < aBase2 )

		{

		return ETrue;	// not necessarily overlapping, but they wrap which is an error

		}

	if( end1 < aBase2 || end2 < aBase1 )

		{

		return EFalse;

		}

	return ETrue;

	}

TInt CRofsMountCB::CheckExtension() 

//

//	Check for a Rofs extension and the end of the primary rofs image

//

	{

	__PRINT(_L("CRofsMountCB::CheckExtension, Looking for Extension"));

	const TUint8 KRofsHeaderId[4] = {'R', 'O', 'F', 'x' };

	const TRofsHeader& h = ((CRofsMountCB*)this)->iHeader();

	//check there is possibly enough room to have an extension

	if( MAKE_TINT64(0,h.iMaxImageSize) + sizeof(TRofsHeader) >= iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, media size too small for extension %x"), I64LOW(iMediaSize) );

		return KErrNotFound;

		}

	TPckgBuf<TRofsHeader> phExt;

	TInt r = LocalDrive()->Read((TInt)h.iMaxImageSize, sizeof(TRofsHeader), phExt);

	if( KErrNone != r )

		return r;		

	const TRofsHeader& hExt = phExt();

	if( 0 != Mem::Compare( KRofsHeaderId, 4, hExt.iIdentifier, 4 ) )

		{

		__PRINT(_L("CRofsMountCB::CheckExtension, [ROFx] ID missing"));

		return KErrNotFound;

		}

	if( hExt.iRofsFormatVersion < KEarliestSupportedFormatVersion

		|| hExt.iRofsFormatVersion > KLatestSupportedFormatVersion )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, unsupported version %x"), h.iRofsFormatVersion );

		return KErrNotSupported;

		}

	if( MAKE_TINT64(0,hExt.iImageSize) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, image size overflow %x"), h.iImageSize );

		return KErrCorrupt;

		}

	if( MAKE_TINT64(0,hExt.iDirTreeOffset) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, dir tree offset %x out-of-range"), h.iDirTreeOffset );

		return KErrCorrupt;

		}

	if( MAKE_TINT64(0,hExt.iDirTreeOffset) + hExt.iDirTreeSize > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, dir tree size %x overflow"), h.iDirTreeSize );

		return KErrCorrupt;

		}

	if( MAKE_TINT64(0,hExt.iDirFileEntriesOffset) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, file entries offset %x out-of-range"), h.iDirFileEntriesOffset );

		return KErrCorrupt;

		}

	if( MAKE_TINT64(0,hExt.iDirFileEntriesOffset) + MAKE_TINT64(0,h.iDirFileEntriesSize) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, file entries size %x overflow"), h.iDirFileEntriesSize );

		return KErrCorrupt;

		}

	if( IsOverlapping( hExt.iDirTreeOffset, hExt.iDirTreeSize,

		hExt.iDirFileEntriesOffset, hExt.iDirFileEntriesSize ) )

		{

		__PRINT1(_L("CRofsMountCB::CheckExtension, dir & file entries overlap"), h.iDirTreeSize );

		return KErrCorrupt;

		}

	Mem::Copy(&iHeader, &phExt, sizeof(TRofsHeader));

	__PRINT(_L("CRofsMountCB::CheckExtension, Valid Extension found"));

	return KErrNone;

	}

TInt CRofsMountCB::CheckHeader() const

//

// Returns KErrNone if the TRofsHeader looks ok, KErrCorrupt if not

//

	{

	const TUint8 KRofsHeaderId[4] = {'R', 'O', 'F', 'S' };

	// nasty cast required until TPckgBuf gains a const accessor member

	const TRofsHeader& h = ((CRofsMountCB*)this)->iHeader();

	if( 0 != Mem::Compare( KRofsHeaderId, 4, h.iIdentifier, 4 ) )

		{

		__PRINT(_L("CRofsMountCB::CheckHeader, [ROFS] ID missing"));

		return KErrCorrupt;

		}

	if( h.iRofsFormatVersion < KEarliestSupportedFormatVersion

		|| h.iRofsFormatVersion > KLatestSupportedFormatVersion )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, unsupported version %x"), h.iRofsFormatVersion );

		return KErrNotSupported;

		}

	if( MAKE_TINT64(0,h.iImageSize) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, image size overflow %x"), h.iImageSize );

		return KErrCorrupt;

		}

	if( MAKE_TINT64(0,h.iDirTreeOffset) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, dir tree offset %x out-of-range"), h.iDirTreeOffset );

		return KErrCorrupt;

		}

	if(TInt64(h.iDirTreeOffset + h.iDirTreeSize) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, dir tree size %x overflow"), h.iDirTreeSize );

		return KErrCorrupt;

		}

	if( MAKE_TINT64(0,h.iDirFileEntriesOffset) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, file entries offset %x out-of-range"), h.iDirFileEntriesOffset );

		return KErrCorrupt;

		}

	if( TInt64(h.iDirFileEntriesOffset + h.iDirFileEntriesSize) > iMediaSize )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, file entries size %x overflow"), h.iDirFileEntriesSize );

		return KErrCorrupt;

		}

	if( IsOverlapping( h.iDirTreeOffset, h.iDirTreeSize,

		h.iDirFileEntriesOffset, h.iDirFileEntriesSize ) )

		{

		__PRINT1(_L("CRofsMountCB::CheckHeader, dir & file entries overlap"), h.iDirTreeSize );

		return KErrCorrupt;

		}

	return KErrNone;

	}

TInt CRofsMountCB::ReMount()

//

// Try and remount this media.

//

	{

	CRofs::Panic( CRofs::EPanicRemountNotSupported );

	return(0);

	}

void CRofsMountCB::VolumeL(TVolumeInfo& aVolume) const

//

// Return the volume info.

//

	{

	aVolume.iFree=0;

	}

void CRofsMountCB::SetVolumeL(TDes& /*aName*/)

//

// Set the volume label.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRofsMountCB::MkDirL(const TDesC& /*aName*/)

//

// Make a directory.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRofsMountCB::RmDirL(const TDesC& /*aName*/)

//

// Remove a directory.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRofsMountCB::DeleteL(const TDesC& /*aName*/)

//

// Delete a file.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRofsMountCB::RenameL(const TDesC& /*anOldName*/,const TDesC& /*aNewName*/)

//

// Rename a file or directory.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRofsMountCB::ReplaceL(const TDesC& /*anOldName*/,const TDesC& /*aNewName*/)

//

// Atomic replace.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRofsMountCB::EntryL(const TDesC& aName,TEntry& aEntry) const

//

// Get entry details.

//

	{

	const TRofsDir* dir;

	const TRofsEntry* entry = NULL;

	iDirectoryCache->FindGeneralEntryL( aName, KEntryAttMaskSupported, dir, entry);

	aEntry.iAtt = entry->iAtt;

	aEntry.iSize = entry->iFileSize;

	aEntry.iModified = ((TPckgBuf<TRofsHeader>&)(iHeader))().iTime;

	aEntry.iName.Des().Copy( CDirectoryCache::NameAddress(entry), entry->iNameLength);

	ReadUidL( entry->iFileAddress, aEntry, (TRofsEntry*)entry );

	}

void CRofsMountCB::ReadUidL( TUint /*aMediaOffset*/, TEntry& aEntry, TRofsEntry* aRofsEntry) const

//

// Internal function to read a uid if present.

//

	{