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