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

// f32\srom\sr_rom.cpp

// 

//

#include "sr_std.h"

#if defined(_UNICODE)

#define __SIZE(len) ((len)<<1)

#else

#define __SIZE(len) (len)

#endif

const TRomHeader* CRom::iRomHeaderAddress=(TRomHeader*)UserSvr::RomHeaderAddress();

TInt TRomDir::BinarySearch(const TDesC& aName, TInt aLengthLimit, TInt aMode, TBool aDir) const

	{

//	RDebug::Print(_L("BinarySearch %S ll=%d m=%d dir=%d"), &aName, aLengthLimit, aMode, aDir);

	const TRomDirSortInfo* s = SortInfo();

	TInt l = aDir ? 0 : s->iSubDirCount;

	TInt r = aDir ? s->iSubDirCount : s->iSubDirCount + s->iFileCount;

	TBool found = EFalse;

	while (r>l)

		{

		TInt m=(l+r)>>1;

		const TRomEntry* e = SortedEntry(m);

		TInt nl = Min(e->iNameLength, aLengthLimit);

		TPtrC en((const TText*)&e->iName[0], nl);

		TInt k = CRomMountCB::Compare(aName, en);

		if (k==0)

			{

			if (aMode == EArrayFindMode_Any)

				{

//				RDebug::Printf("Found %d", m);

				return m;

				}

			found = ETrue;

			if (aMode == EArrayFindMode_First)

				r=m;

			else

				l=m+1;

			}

		else if (k>0)

			l=m+1;

		else

			r=m;

		}

//	RDebug::Printf("Found=%d r=%d", found, r);

	return found ? r : KErrNotFound;

	}

// Navigate the path to find the leaf directory, starting at this.

const TRomDir* TRomDir::FindLeafDir(const TDesC& aPath) const

	{

	TLex lex(aPath);

	TInt r;

	const TRomDir* d = this;

	FOREVER

		{

		lex.Inc(); // Skip the file separator

		lex.Mark();

		r=lex.Remainder().Locate(KPathDelimiter);

		if (r==KErrNotFound)

			r=lex.Remainder().Length();

		if (r==0) // End of the path

			break;

		lex.Inc(r); // Set the token length

		TInt ix = d->BinarySearch(lex.MarkedToken(), KMaxTInt, EArrayFindMode_Any, ETrue);

		if (ix<0)

			return NULL;

		const TRomEntry* e = d->SortedEntry(ix);

//		if (!(e->iAtt & KEntryAttDir))

//			return NULL;

		d = (const TRomDir*)e->iAddressLin;

		}

	return d;

	}

LOCAL_C void Fault(TFault aFault)

//

// Report a fault in the rom file system.

//

	{

	User::Panic(_L("ROMFILESYS"),aFault);

	}

CRomMountCB::CRomMountCB(const CRom* aRom)

//

// Constructor

//

	: iRom(aRom)

	{

	}

void CRomMountCB::Dismounted()

//

// Dummy implementation of pure virtual function

//

	{}

void CRomMountCB::IsFileInRom(const TDesC& aName,TUint8*& aFileStart)

//

// Return the address of the file if it is in rom

//

	{

	TLinAddr dir;

	TLinAddr entry=0;

	aFileStart=NULL;

	TRAPD(r,FindEntryL(aName,KEntryAttNormal,ETrue,dir,entry));

	if (r!=KErrNone)

		return;

	aFileStart=(TUint8*)((const TRomEntry*)entry)->iAddressLin;

	}

TInt CRomMountCB::Compare(const TDesC& aLeft, const TDesC& aRight)

//

//Compares two filenames.  Folds ASCII characters to uppercase

//

	{

	TInt ll = aLeft.Length();

	TInt rl = aRight.Length();

	TInt len = Min(ll, rl);

	const TText* l = aLeft.Ptr();

	const TText* r = aRight.Ptr();

	while (len--)

		{

		TText lc = *l++;

		TText rc = *r++;

		if (lc >= 'A' && lc <= 'Z')

			lc += ('a' - 'A');

		if (rc >= 'A' && rc <= 'Z')

			rc += ('a' - 'A');

		TInt x = lc - rc;

		if (x)

			return x;

		}

	// match up to end of shorter string, now compare lengths

	return ll - rl;

	}

void CRomMountCB::FindBinaryL(const TDesC& aName, TUint aAtt, TBool aAttKnown, TLinAddr aDir, TLinAddr& aEntry, TInt aError) const

//

//Identical to FindL, but uses binary search for faster performance.

//However, can't deal with wildcards, whereas FindL can.

//

	{

	//Although the value of aEntry is not used, we expect it to be zero,

	__ASSERT_DEBUG(aEntry==0,Fault(ERomInvalidArgument));

	const TRomDir* d = (const TRomDir*)aDir;

	TBool ix;

	if (aAttKnown)

		ix = d->BinarySearch(aName, KMaxTInt, EArrayFindMode_Any, aAtt & KEntryAttDir);

	else

		{

		//We don't know whether we're looking for a file or a directory, so

		//look through both

		ix = d->BinarySearch(aName, KMaxTInt, EArrayFindMode_Any, EFalse);

		if (ix<0 || !MatchEntryAtt(d->SortedEntry(ix)->iAtt, aAtt) )

			ix = d->BinarySearch(aName, KMaxTInt, EArrayFindMode_Any, ETrue);

		}

	if (ix>=0)

		{

		const TRomEntry* e = d->SortedEntry(ix);

		if (MatchEntryAtt(e->iAtt, aAtt))

			{

			aEntry = (TLinAddr)e;

			return;

			}

		}

	User::Leave(aError);

	}

void CRomMountCB::FindL(const TDesC& aName, TUint anAtt, TLinAddr aDir, TLinAddr& anEntry, TInt anError) const

//

// Scan from aDir looking for aName.

// If found return the result in anEntry.

//

	{

	const TRomDir* pD = (const TRomDir*)aDir;

	const TRomEntry* pE;

	if (anEntry==0)

		pE = &pD->iEntry;

	else

		{

		pE = (const TRomEntry*)anEntry;

		pE = PtrAdd(pE, Align4(__SIZE(pE->iNameLength) + KRomEntrySize));

		}

	const TRomEntry* pEnd = PtrAdd(&pD->iEntry, pD->iSize);

	while (pE<pEnd)

		{

		TPtrC name = TPtrC((const TText*)&pE->iName[0], pE->iNameLength);

		if (name.MatchF(aName)!=KErrNotFound && MatchEntryAtt(pE->iAtt, anAtt))

			{

			anEntry = (TLinAddr)pE;

			return;

			}

		pE = PtrAdd(pE, Align4(__SIZE(pE->iNameLength) + KRomEntrySize));

		}

	User::Leave(anError);

	}

void CRomMountCB::FindEntryL(const TDesC& aName, TUint anAtt, TBool aAttKnown, TLinAddr& aDir, TLinAddr& anEntry) const

//

// Locate an entry from its full path name.

//

	{

	TInt namePos=aName.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter

	const TRomDir* d = ((const TRomDir*)RomRootDirectory())->FindLeafDir(aName.Left(namePos));

	if (!d)

		User::Leave(KErrPathNotFound);

	anEntry=0;

	aDir = (TLinAddr)d;

	FindBinaryL(aName.Mid(namePos),anAtt,aAttKnown,aDir,anEntry,KErrNotFound);

	}

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

//

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

//

	{

	iUniqueID=0;

	iSize=(TUint)RomHeader().iUncompressedSize;

	SetVolumeName(_L("RomDrive").AllocL());

	}

TInt CRomMountCB::ReMount()

//

// Try and remount this media.

//

	{

	Fault(ERomReMountNotSupported);

	return(0);

	}

void CRomMountCB::VolumeL(TVolumeInfo& aVolume) const

//

// Return the volume info.

//

	{

	aVolume.iFree=0;

	}

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

//

// Set the volume label.

//

	{

	User::Leave(KErrAccessDenied);

	}

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

//

// Make a directory.

//

	{

	User::Leave(KErrAccessDenied);

	}

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

//

// Remove a directory.

//

	{

	User::Leave(KErrAccessDenied);

	}

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

//

// Delete a file.

//

	{

	User::Leave(KErrAccessDenied);

	}

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

//

// Rename a file or directory.

//

	{

	User::Leave(KErrAccessDenied);

	}

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

//

// Atomic replace.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomMountCB::EntryL(const TDesC& aName,TEntry& anEntry) const

//

// Get entry details.

//

	{

	TLinAddr dir;

	TLinAddr entry;

	FindEntryL(aName,KEntryAttMaskSupported,EFalse,dir,entry);

	const TRomEntry* pE = (const TRomEntry*)entry;

	anEntry.iAtt=pE->iAtt;

	anEntry.iSize=pE->iSize;

	anEntry.iModified=RomHeader().iTime;

	anEntry.iName.Des().Copy((TText*)&pE->iName[0],pE->iNameLength);

	ReadUidL(pE->iAddressLin,anEntry);

	}

void CRomMountCB::SetEntryL(const TDesC& /*aName*/,const TTime& /*aTime*/,TUint /*aMask*/,TUint /*aVal*/)

//

// Set entry details.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomMountCB::FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile)

//

// Open a file on the current mount.

//

	{

	if (aMode&EFileWrite)

		User::Leave(KErrAccessDenied);

	switch (anOpen)

		{

	case EFileCreate:

	case EFileReplace:

		User::Leave(KErrAccessDenied);

	case EFileOpen:

		break;

	default:

		User::Leave(KErrAccessDenied);

		}

	TLinAddr dir;

	TLinAddr entry;

	FindEntryL(aName,KEntryAttMustBeFile,ETrue,dir,entry);

	const TRomEntry* pE = (const TRomEntry*)entry;

	CRomFileCB& file=(*((CRomFileCB*)aFile));

	file.SetSize(pE->iSize);

	file.SetAtt(pE->iAtt);

	file.SetModified(RomHeader().iTime);

	file.SetBase((const TUint8*)pE->iAddressLin);

	}

void CRomMountCB::DirOpenL(const TDesC& aName, CDirCB* aDir)

//

// Open a file on the current mount.

//

	{

    TFileName fileName=aName;

    TInt namePos=aName.LocateReverse(KPathDelimiter)+1; // Exclude path delimiter

    if (namePos==aName.Length())

        fileName+=_L("*");

	const TRomDir* d = ((const TRomDir*)RomRootDirectory())->FindLeafDir(aName.Left(namePos));

	if (!d)

		User::Leave(KErrPathNotFound);

	CRomDirCB& dirCB = *(CRomDirCB*)aDir;

	dirCB.SetDir((TLinAddr)d, NULL, fileName.Mid(namePos));

	}

void CRomMountCB::RawReadL(TInt64 aPos,TInt aLength,const TAny* aDes,TInt anOffset,const RMessagePtr2& aMessage) const

//

// Read up to aLength data directly from the ROM

//

	{

	TUint romSize=RomHeader().iUncompressedSize;

	if (I64LOW(aPos)>=romSize)

		aMessage.WriteL(2,TPtrC8(NULL,0),anOffset);

	else

		{

		TInt len=Min((TInt)(romSize-I64LOW(aPos)),aLength);

		aMessage.WriteL(2,TPtrC8((TUint8*)RomHeader().iRomBase,len),anOffset);

		}

	}

void CRomMountCB::RawWriteL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aDes*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/)

//

// Write aLength data to ROM (?)

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomMountCB::ReadUidL(TLinAddr anAddr,TEntry& anEntry) const

//

// Read a uid if present.

//

	{

	// Need to consider zero-length files (for which anAddr is 0)

	// and files too small to have a UID

	if (anEntry.iSize >= (TInt) sizeof(TCheckedUid))

		{

		TCheckedUid entryUid(TPtrC8((TUint8*)anAddr, sizeof(TCheckedUid)));

		anEntry.iType=entryUid.UidType();

		}

	else

		{

		anEntry.iType=KNullUid;

		}

	}

void CRomMountCB::ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)

	{

	__PRINT(Print(_L("CRomMountCB::ReadSectionL")));

	TLinAddr dir;

	TLinAddr entry;

	FindEntryL(aName,KEntryAttMustBeFile,ETrue,dir,entry);

	const TRomEntry* pE = (TRomEntry*)entry;

	TInt size=pE->iSize;

	const TText8* baseAddress = (const TText8*)pE->iAddressLin;

	if (size>=(aPos+aLength)) //|| (size>aPos)

		{

		TPtrC8 section((baseAddress+aPos),aLength);

		aMessage.WriteL(0,section,0);

		}

	else if (size>aPos)

		{

		aLength=(size-aPos);

		TPtrC8 section((baseAddress+aPos),aLength);

		aMessage.WriteL(0,section,0);

		}	

	else

		User::Leave(KErrEof);

	}

void CRomMountCB::GetShortNameL(const TDesC& /*aLongName*/,TDes& /*aShortName*/)

//

// Return the short name associated with aLongName

// Assumes all rom names are 8.3

//

	{

	User::Leave(KErrNotSupported);

	}

void CRomMountCB::GetLongNameL(const TDesC& /*aShortName*/,TDes& /*aLongName*/)

//

// Return the short name associated with aLongName

// Assumes all rom names are 8.3

//

	{

	User::Leave(KErrNotSupported);

	}	

TInt CRomMountCB::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput) 

//

// Access the specified interface; behaviour is interface-specific

//

	{

	switch(aInterfaceId)

		{

		case (CMountCB::EFileAccessor):

			{

			((CMountCB::MFileAccessor*&) aInterface) = this;

			return KErrNone;

			}

		default:

			return (CMountCB::GetInterface(aInterfaceId,aInterface,aInput));

		}

	}

TInt CRomMountCB::GetFileUniqueId(const TDesC& /* aName */, TInt64& aUniqueId)

	{

	// Get unique identifier for the file - for ROM File System will just return zero

	aUniqueId = MAKE_TINT64(0,0);

	return KErrNone;

	}

TInt CRomMountCB::Spare3(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/)

	{

	return KErrNotSupported;

	}

TInt CRomMountCB::Spare2(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/)

	{

	return KErrNotSupported;

	}

TInt CRomMountCB::Spare1(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/)

	{

	return KErrNotSupported;

	}

CRomFileCB::CRomFileCB(const CRom* aRom)

//

// Constructor

//

	: iRom(aRom)

	{

	}

void CRomFileCB::ReadL(TInt aPos,TInt& aLength,const TAny* aTrg,const RMessagePtr2& aMessage)

//

// Read from the file.

//

	{

	__PRINT(Print(_L("CRomFileCB::ReadL")));

	if (aPos>=iSize)

		{

        TPtrC8 nullBuf(NULL,0);

		aMessage.WriteL(0,nullBuf,0);

		aLength=0;

		}

	else

		{

		TInt len=Min((iSize-aPos),aLength);

        TPtrC8 romBuf(iBase+aPos,len);

//		thread->WriteL(aTrg,romBuf,0);

		aMessage.WriteL(0,romBuf,0);

		aLength=len;

		}

	}

void CRomFileCB::WriteL(TInt /*aPos*/,TInt& /*aLength*/,const TAny* /*aDes*/,const RMessagePtr2& /*aMessage*/)

//

// Write to the file.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomFileCB::RenameL(const TDesC& /*aDes*/)

//

// Rename the file.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomFileCB::SetSizeL(TInt /*aSize*/)

//

// Set the file size.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomFileCB::SetEntryL(const TTime& /*aTime*/,TUint /*aMask*/,TUint /*aVal*/)

//

// Set the entry's attributes and modified time.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomFileCB::FlushAllL()

//

// Commit any buffered date to the media.

//

	{

	User::Leave(KErrAccessDenied);

	}

void CRomFileCB::FlushDataL()

//

// Commit any buffered date to the media.

//

	{

	User::Leave(KErrAccessDenied);

	}

TInt CRomFileCB::Address(TInt& aPos) const

//

// Return address of the file at aPos. Default implementation.

//

	{

	if (aPos>=iSize)

		return(KErrEof);

	aPos=(TInt)(iBase+aPos);

	return(KErrNone);

	}

CRomDirCB::CRomDirCB(const CRom* aRom)

//

// Constructor

//

	: iRom(aRom)

	{

	}

CRomDirCB::~CRomDirCB()

//

// Destruct

//

	{

	delete iMatch;

	}

TBool CRomDirCB::MatchUid()

//

// Match the uid ?

//

	{

	if (iUidType[0]!=TUid::Null() || iUidType[1]!=TUid::Null() || iUidType[2]!=TUid::Null())

		return(ETrue);

	return(EFalse);

	}

LOCAL_C TBool CompareUid(const TUidType& aUidTrg, const TUidType& aUidSuitor)

//

// Compare the suitor to the target pattern

//

	{

	if (aUidTrg[0]!=TUid::Null() && aUidTrg[0]!=aUidSuitor[0])

		return(EFalse);

	if (aUidTrg[1]!=TUid::Null() && aUidTrg[1]!=aUidSuitor[1])

		return(EFalse);

	if (aUidTrg[2]!=TUid::Null() && aUidTrg[2]!=aUidSuitor[2])

		return(EFalse);

	return(ETrue);

	}

void CRomDirCB::ReadL(TEntry& anEntry)

//

// Read the next entry from the directory.

//

	{

	CRomMountCB& mount=(CRomMountCB&)Mount();

	const TRomEntry* pE;

	FOREVER

		{

		//

		//May be called with wildcards in the path, so we need

		//to call the slow, sequential FindL

		//

		if (!iPending)

			mount.FindL(*iMatch,iAtt,iDir,iNext,KErrEof);

		iPending=EFalse;

		pE = (const TRomEntry*)iNext;

		iEntry.iName.Des().Copy((TText*)&pE->iName[0],pE->iNameLength);

		iEntry.iAtt=pE->iAtt;

		iEntry.iSize=pE->iSize;

		iEntry.iModified=RomHeader().iTime;

		anEntry=iEntry;

		if (MatchUid())

			{

			mount.ReadUidL(pE->iAddressLin,anEntry);

			if (CompareUid(iUidType,anEntry.iType))

				break;

			}

		else

			break;

		}

	if (iAtt&KEntryAttAllowUid && (anEntry.iAtt&KEntryAttDir)==0 && MatchUid()==EFalse)

		mount.ReadUidL(pE->iAddressLin,anEntry);

	}

void CRomDirCB::SetDir(TLinAddr aDir,TLinAddr anEntry,const TDesC& aName)

//

// Set the directory and entry that we are on after open.

//

	{

    iDir=aDir;

	iNext=anEntry;

	iMatch=aName.AllocL();

	iPending=(anEntry!=NULL);

	}

CRom::CRom()

//

// Constructor

//

	{

	}

CRom::~CRom()

//

// Destruct

//

	{

	}

TInt CRom::Install()

//

// Install the file system.

//

	{

	iVersion=TVersion(KF32MajorVersionNumber,KF32MinorVersionNumber,KF32BuildVersionNumber);

    TPtrC name=_L("Rom");

	return(SetName(&name));

	}

CMountCB* CRom::NewMountL() const

//

// Create a new mount control block.

//

	{

	return(new(ELeave) CRomMountCB(this));

	}

CFileCB* CRom::NewFileL() const

//

// Create a new file.

//

	{

	return(new(ELeave) CRomFileCB(this));

	}

CDirCB* CRom::NewDirL() const

//

// Create a new directory lister.

//

	{

	return(new(ELeave) CRomDirCB(this));

	}

CFormatCB* CRom::NewFormatL() const

//

// Create a new media formatter.

//

	{

	User::Leave(KErrAccessDenied);

	return(NULL);

	}

void CRom::DriveInfo(TDriveInfo& anInfo,TInt /*aDriveNumber*/) const

//

// Return the drive info.

//

	{

	anInfo.iDriveAtt=KDriveAttRom|KDriveAttInternal;

	anInfo.iMediaAtt=KMediaAttWriteProtected;

	anInfo.iType=EMediaRom;

	}

GLDEF_C void InstallRomFileSystemL()

//

// Create the ROM file system.

//

	{

	CFileSystem* pS=new(ELeave) CRom;

	CleanupStack::PushL(pS);

	User::LeaveIfError(InstallFileSystem(pS,RLibrary()));

	CleanupStack::Pop(1, pS);

	}

GLDEF_C const TRomHeader *RomHeader(CFileSystem *aFsys)

//

// Return the ROM header

//

	{

	return &((CRom *)aFsys)->RomHeader();

	}