// Copyright (c) 2003-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 "sc_std.h"

 const TInt KMajorVersionNumber=1;

 const TInt KMinorVersionNumber=1;

 _LIT(KRofsName,"Rofs");

 #ifdef __WINS__

 _LIT(KRomName,"Win32");

 #else

 _LIT(KRomName,"Rom");

 #endif

 _LIT(KCompositeName,"Composite");

 static void Fault(TCompFault aFault)

 //

 // Report a fault in the composite file system.

 //

 	{

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

 	}

 CCompFileSystem::CCompFileSystem()

 	{

 	__PRINT1(_L("CCompFileSystem()[0x%x]"), this);

 	}

 CCompFileSystem::~CCompFileSystem()

 	{

 	__PRINT1(_L("~CCompFileSystem()[0x%x]"),this);

 	if (iMount)

 		{

 		iMount->NullCompFileSystem();

 		}

 	}

 TInt CCompFileSystem::Install()

 //

 // Install the file system

 //

 	{

 	__PRINT1(_L("CCompFileSystem::Install()[0x%x]"), this);

 	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KF32BuildVersionNumber);

 	return(SetName(&KCompositeName));

 	}

 CMountCB* CCompFileSystem::NewMountL() const

 //

 // Create a new mount control block

 //

 	{

 	__PRINT1(_L("CCompFileSystem::NewMountL()[0x%x]"), this);

  	// Composite FS is a singleton, and can only have one mount.

  	// If it already exists, just return the existin one.

  	if (iMount == NULL)

  		{

  		((CCompFileSystem*)this)->iMount = new(ELeave) CCompMountCB((CCompFileSystem *)this);

 		TRAPD(err,iMount->NewRomMountL());

 		if(err!=KErrNone)

 			{

 			iMount->Close();

 			User::Leave(err);

 			}

  		}

 	__PRINT1(_L("  created CCompMountCB:0x%x"),iMount);

 	return (iMount);

 	}

 CFileCB* CCompFileSystem::NewFileL() const

 //

 // Create a new file

 //

 	{

 	__PRINT(_L("CCompFileSystem::NewFileL()"));

 	CFileCB* pFile=new(ELeave) CCompFileCB;

 	__PRINT1(_L("file at 0x%x"),pFile);

 	return(pFile);

 	}

 CDirCB* CCompFileSystem::NewDirL() const

 //

 // create a new directory lister

 //

 	{

 	__PRINT(_L("CCompFileSystem::NewDirL()"));

 	CCompDirCB* pDir=new (ELeave) CCompDirCB;

 	CleanupStack::PushL(pDir);

 	TInt count = iMount->iMounts.Count();

     TInt  r=KErrNone;

 	for(TInt idx=0; idx<count; idx++)

 		{

 	    TRAPD(err, r=pDir->iDirs.Append(iMount->iMounts[idx].iFs->NewDirL()));

 		if(err!= KErrNone || r != KErrNone)

 			{

 			pDir->Close();

 			User::Leave(err == KErrNone ? r : err);

 			}

         }

 	CleanupStack::Pop(pDir);

     __PRINT1(_L("dir at 0x%x"),pDir);

 	return(pDir);		

 	}

 CFormatCB* CCompFileSystem::NewFormatL() const

 //

 // Create a new media formatter

 //

 	{

 	User::Leave(KErrAccessDenied);

 	return(NULL);

 	}

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

 //

 // Return drive info

 //

 	{

 	__PRINT(_L("CCompFileSystem::DriveInfo()"));

 	anInfo.iMediaAtt=KMediaAttWriteProtected;

 	anInfo.iDriveAtt=KDriveAttRom|KDriveAttInternal;

 	anInfo.iType=EMediaRom;

 	}

 TInt CCompFileSystem::DefaultPath(TDes& /*aPath*/) const

 //

 // Return the initial default path.

 //

 	{

 	Fault(ECompFsDefaultPath);

 	return(KErrNone);

 	}

 CFileSystem* CCompFileSystem::NewL()

 //

 //

 //

 	{

 	__PRINT(_L("CCompFileSystem::NewL()"));

 	CCompFileSystem* pFs = new(ELeave) CCompFileSystem;

 	__PRINT1(_L("CompFs=0x%x"),pFs);

 	return (pFs);

 	}

 CCompMountCB::~CCompMountCB()

 //

 //

 //

 	{

   	__PRINT1(_L("~CCompMountCB() this=0x%x"),this);

 	for(TInt mount=iMounts.Count(); mount--;)

 		iMounts[mount].iMount->Close();

 	iMounts.Close();

 	if (iFileSystem)

 		{

 		iFileSystem->NullMount();

 		}

 	}

 void CCompMountCB::NewRomMountL()

 //

 // Creates a new ROM mount, and adds it to the list.

 //

 {

 	CFileSystem* romFs= GetFileSystem(KRomName);

 	if(!romFs)

 		{

 		User::Leave(KErrNotFound);

 		}

 	CMountCB* romMount = romFs->NewMountL();	    	

     User::LeaveIfError(iMounts.Append(TCompMount(romFs,romMount)));

 }

 void CCompMountCB::MountL(TBool aForceMount)

 //

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

 //

 //

 	{

 	__PRINT(_L("CCompMountCB::MountL()"));

 	// First mount rom

 	RomMount()->SetDrive(&Drive());

 	RomMount()->MountL(aForceMount);

 	// Mounts count starts at 1, as ROMFS starts in slot one.

 	// If its still 1 on mount, then no mounts have been added.

 	// To maintain compatibility with the previous version of this API,

 	// (where you couldn't specifically add mounts) in this case we mount

 	// ROFS by default.  

 	// (There would be little point mounting it with only one FS)

 	if (iMounts.Count()==1) 

 		{

 		CFileSystem* rofsFs = GetFileSystem(KRofsName);

 		if(!rofsFs)

 			User::Leave(KErrUnknown);

 		AddFsToCompositeMount(rofsFs);

 		}

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

 	// combine sizes

 	for(TInt mount=iMounts.Count(); mount--;)

 		iSize+= iMounts[mount].iMount->Size();

 	// no need to update iUniqueID since 0 in both rom and rofs

 	}

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

 	{

 	// aInterfaceId	: If EAddFsToCompositeMount, method mounts a media and adds to CompFS.

 	//				: Local drive mapping for this mount's drive (CompFS's) 

 	//				  should be alterd to indicate the local drive to be added.

 	// aIntput    	: CFileSystem* for the mount to be added.

 	// aInterFace	: Unused.

 	switch(aInterfaceId)

 		{

 		case CMountCB::EFileAccessor:

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

 			return KErrNone;

 		case EAddFsToCompositeMount:

 			return(AddFsToCompositeMount((CFileSystem*) aInput));

 		case CMountCB::ELocalBufferSupport:

 			{

 			CCompFileCB* file = (CCompFileCB*) aInput;

 			return file?file->TrueFile()->Mount().LocalBufferSupport():KErrNone;

 			}

 		default:

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

 		}

 	}

 /**

     Mounts a media with the provided filesystem and adds to the composite mount.  

     Local drive mapping for this mount's drive (CompFS's) should be altered to indicate the local drive to be added.

 */

 TInt CCompMountCB::AddFsToCompositeMount(CFileSystem* aFileSystem)

  	{

  	__PRINT1(_L("CCompMountCB::AddFsToCompositeMount(0x%x)"), aFileSystem);

     CMountCB* newMount=NULL;

 	TRAPD(err,newMount = aFileSystem->NewMountL());

 	if (err==KErrNone)

 		{

         newMount->InitL(Drive(), aFileSystem);

         TRAP(err,newMount->MountL(EFalse));

 		if (err==KErrNone)

 			{

 		    err = iMounts.Append(TCompMount(aFileSystem,newMount));

             if (err!=KErrNone) 

             return err;	

 			TInt r = newMount->AddToCompositeMount(iMounts.Count()-1);

 			if(r == KErrNotSupported)

 				r = KErrNone;

             return r;	

 			}

 		}

     return err;

  	}

 TInt CCompMountCB::ReMount()

 //

 // Try and remount this media.

 //

 	{

 	return(0);

 	}

 void CCompMountCB::Dismounted()

 //

 // Dummy implementation of pure virtual function

 //

 	{}

 void CCompMountCB::VolumeL(TVolumeInfo& aVolume) const

 //

 //

 // Return the volume info.

 //

 	{

 	__PRINT(_L("CCompMountCB::VolumeL()"));

 	aVolume.iFree=0;

 	}

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

 //

 //

 // Set the volume label.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 //

 // Make a directory.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 //

 // Remove a directory.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 //

 // Delete a file.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 void CCompMountCB::RenameL(const TDesC& /*anOldName*/,const TDesC& /*anNewName*/)

 //

 // Rename a file or directory.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 void CCompMountCB::ReplaceL(const TDesC& /*anOldName*/,const TDesC& /*anNewName*/)

 //

 // Atomic replace.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 //

 // Get entry details.

 //

 	{

 	__PRINT(_L("CCompMountCB::EntryL()"));

 	TInt lesserErr = KErrNone;

 	TInt err = KErrPathNotFound;

 	TInt idx = iMounts.Count();

 	// Look for entry on each mount, until it finds one, starting at the top.

 	while(idx--)

 		{

 		TRAP(err, iMounts[idx].iMount->EntryL(aName,anEntry));

 		// There will often be more then one error encountered when trying

 		// to find an entry.  If the entry is not found on any mount, but it

 		// did find its path, it should not return a path error.

 		// To ensure this, the last non-path related error must be remembered.

 		if ((err != KErrPathNotFound) && (err != KErrPathHidden))

 			lesserErr=err;

 		// It can stop looking for the entry when it either finds it

 		// or discovers its hidden. (ie An error other then NotFound)

 		if((err != KErrNotFound) && (err != KErrPathNotFound))

 			break;

 		}

 	if (err!=KErrNone)

 		User::Leave(lesserErr?lesserErr:err);

 	}

 void CCompMountCB::SetEntryL(const TDesC& /*aName*/,const TTime& /*aTime*/,TUint /*aSetAttMask*/,TUint /*aClearAttMask*/)

 //

 // Set entry details.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 static TInt InitFile(CFileCB* aCompFile, CFileCB* aTrueFile,CMountCB* aRealMount,TUint8 aQueOffset)

 //

 // Initialise the true file object with values set in the composite file object

 // by TDrive

 //

 	{

     TRAPD(r,aTrueFile->InitL(&aCompFile->Drive(),&aCompFile->Drive(),aCompFile->FileName().Des().AllocL() ) );

 	if(r!=KErrNone)

 		return(r);

 	aTrueFile->SetMount(aRealMount);

 	aTrueFile->SetShare(aCompFile->Share());

 	r=aTrueFile->Mount().Open();

 	if(r==KErrNone)

 		{

 		// destructor for CFileCB only calls close on the mount if iMountLink set

 		TDblQue<CFileCB>* pQue=(TDblQue<CFileCB>*)((TUint8*)aRealMount+aQueOffset);

 		pQue->AddLast(*aTrueFile);

 		}

 	return(r);

 	}

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

 //

 // Open a file on the current mount.

 //

 	{

 	__PRINT1(_L("CCompMountCB::FileOpenL() %S"), &aName);

 	TInt err = KErrPathNotFound;

 	TInt lesserErr = KErrNone;

 	CFileCB* pTrueFile = NULL;

 	TInt idx = iMounts.Count();

 	// Look for file on each mount, until it finds one, starting at the top.

 	while(idx--)

 		{

 		CMountCB* mount = iMounts[idx].iMount;

 		pTrueFile = iMounts[idx].iFs->NewFileL();

 		TUint8 offset=(TUint8)(((TUint8*)&iMountQ-(TUint8*)this));

 		err = InitFile(aFile,pTrueFile,mount,offset);

 		if(err == KErrNone)

 			TRAP(err, mount->FileOpenL(aName,aMode,anOpen,pTrueFile));

 		__PRINT2(_L("opening file on mount %d [err=%d]"),idx,err);

 		// If success, stop looking.

 		if (err == KErrNone)

 			break;

 		// Not opened, so use Close() to cause file object to be deleted

 		pTrueFile->Close();

 		// If the file is not found on any mount, but it did find its path,

 		// it should not return a path error.

 		// To ensure this, the last non-path related error must be remembered.

 		if ((err != KErrPathNotFound) && (err != KErrPathHidden))

 			lesserErr=err;

 		// Stop search if error other than file cannot be found.

 		// A common error for this will be one of the hidden errors.

 		// Note that for these, the lesser error calculation above

 		// is still needed for these. 

 		if(err != KErrNotFound && err != KErrPathNotFound)

 			break;

 		}

 	if (err!=KErrNone)

 		User::Leave(lesserErr?lesserErr:err);

 	aFile->SetSize(pTrueFile->Size());

 	aFile->SetAtt(pTrueFile->Att());

 	aFile->SetModified(pTrueFile->Modified());

 	((CCompFileCB*)aFile)->SetTrueFile(pTrueFile);

 	}

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

 	{

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

 	aUniqueId = MAKE_TINT64(0,0);

 	return KErrNone;

 	}

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

 	{

 	return KErrNotSupported;

 	}

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

 	{

 	return KErrNotSupported;

 	}

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

 	{

 	return KErrNotSupported;

 	}

 static void SetAtt(CDirCB* aDir,TUint8 aOffset,TUint aValue)

 //

 //

 //

 	{	

 	TUint8* pA=(TUint8*)aDir+aOffset;

 	*(TUint*)pA=aValue;	

 	}

 static void SetUid(CDirCB* aDir,TUint8 aOffset,TUidType aValue)

 //

 //

 //

 	{

 	TUint8* pU=(TUint8*)aDir+aOffset;

 	*(TUidType*)pU=aValue;

 	}

 TInt CCompDirCB::InitDir(CDirCB* aTrg,CMountCB* aMount)

 //

 //

 //

 	{

 	TRAPD(r,aTrg->InitL(&Drive()));

 	if(r!=KErrNone)

 		return(r);

 	aTrg->SetMount(aMount);

 	r=aTrg->Mount().Open();

 	if(r!=KErrNone)

 		{

 		aTrg->SetMount(NULL);

 		return(r);

 		}

 	SetAtt(aTrg,(TUint8)((TUint8*)&iAtt-(TUint8*)this),iAtt);

 	SetUid(aTrg,(TUint8)((TUint8*)&iUidType-(TUint8*)this),iUidType);

 	aTrg->Mount().DecLock();

 	return(KErrNone);

 	}

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

 //

 // Open a directory on the current mount.

 //

 	{

 	__PRINT(_L("CCompMountCB::DirOpenL()"));

 	CCompDirCB* pD=(CCompDirCB*)aDir;

 	pD->iMatch=aName.AllocL();

 	TInt err = KErrPathNotFound;

 	TInt idx = iMounts.Count();

 	TBool anyFound = EFalse;

 	pD->iCurrentDir = -1;

 	while(idx) // Open dir on every mount it exists.

 		{

 		idx--;

 		CDirCB* theDir = pD->iDirs[idx];

 		CMountCB* theMount = iMounts[idx].iMount;

 		err = pD->InitDir(theDir, theMount);

 		if(err == KErrNone)

 			TRAP(err, theMount->DirOpenL(aName,theDir));

 		if(err == KErrNone)

 			{

 			if(!anyFound)

 				{

 				anyFound = ETrue;

 				pD->iCurrentDir = idx;

 				}

 			continue;

 			}

 		pD->iDirs[idx]->Close(); // deletes object

 		pD->iDirs[idx] = NULL;

 		if (err == KErrPathHidden)

 			{

 			// Dont look for anythng below this hidden dir.

 			break;

 			}

 		else if (err != KErrPathNotFound)

 			{

 			// An unexpected error - make it report this to caller!

 			anyFound = EFalse;

 			break;

 			}

 		}

 	// If we broke before bottom, close the remaining

 	while (idx--)

 		{

 		pD->iDirs[idx]->Close();

 		pD->iDirs[idx] = NULL;

 		}

 	// If we didnt find anythng at all, or some other error, leave.

 	if(!anyFound) 

 		User::Leave(err);

 	}

 void CCompMountCB::RawReadL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aTrg*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/) const

 //

 // Read up to aLength data directly

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 //

 // Write aLength data

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 //

 // Return the short name associated with aLongName

 // Assumes all rom names are 8.3

 //

 	{

 	User::Leave(KErrNotSupported);

 	}

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

 //

 // Return the short name associated with aLongName

 // Assumes all rom names are 8.3

 //

 	{

 	User::Leave(KErrNotSupported);

 	}	

 void CCompMountCB::IsFileInRom(const TDesC& aFileName,TUint8*& aFileStart)

 //

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

 //

 	{

 	__PRINT(_L("CCompMountCB::IsFileInRom()"));

 	TEntry entry;

 	aFileStart=NULL;

 	TInt idx = iMounts.Count();

 	while(idx--)

 		{

 		TRAPD(r,iMounts[idx].iMount->EntryL(aFileName,entry));

 		if(r==KErrNone)

 			{

 			// File exists on mount, check whether it is rom-based

 			iMounts[idx].iMount->IsFileInRom(aFileName,aFileStart);

 			break;

 			}

 		else if(r != KErrNotFound && r != KErrPathNotFound)

 			{

 			break;

 			}	

 		}

 	}

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

 //

 //	Starting from aPos, read aLength bytes of a file into a Trg, 

 //	regardless of lock state

 //

 	{

 	__PRINT(_L("CCompMountCB::ReadSectionL()"));

 	TInt lesserErr = KErrNone;

 	TInt err = KErrPathNotFound;

 	TInt idx = iMounts.Count();

 	 // Look for file on each mount, until it finds one, starting at the top.

 	while(idx--)

 		{

 		TRAP(err, iMounts[idx].iMount->ReadSectionL(aName,aPos,aTrg,aLength,aMessage));

 		// If the file is not found on any mount, but it did find its path,

 		// it should not return a path error.

 		// To ensure this, the last non-path related error must be remembered.

 		if ((err != KErrPathNotFound) && (err != KErrPathHidden))

 			lesserErr=err;

 		// Break if file was found, it was hidden, or some unexpected error

 		// (ie break if file or pathe not found)

 		// Note: If hidden, lesserErr calulation above still needed.

 		if ((err != KErrNotFound) && (err != KErrPathNotFound))

 			break;

 		}

 	if (err!=KErrNone)

 		User::Leave(lesserErr?lesserErr:err);

 	}

 CCompFileCB::CCompFileCB()

 	{}

 CCompFileCB::~CCompFileCB()

 	{

 	__PRINT1(_L("~CCompFileCB()[0x%x]"),this);

 	if(TrueFile())

 		TrueFile()->Close();

 	}

 void CCompFileCB::RenameL(const TDesC& /*aNewName*/)

 //

 // Rename the file.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 void CCompFileCB::ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)

 //

 // Read from the file.

 //

 	{

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

 	TrueFile()->ReadL(aPos,aLength,aDes,aMessage);

 	}

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

 //

 // Write to the file.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 TInt CCompFileCB::Address(TInt& aPos) const

 //

 // Return address of the file at aPos

 //

 	{

 	__PRINT(_L("CCompFileCB::Address()"));

 	return(TrueFile()->Address(aPos));

 	}

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

 //

 // Set the file size.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 void CCompFileCB::SetEntryL(const TTime& /*aTime*/,TUint /*aSetAttMask*/,TUint /*aClearAttMask*/)

 //

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

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 void CCompFileCB::FlushDataL()

 //

 // Commit any buffered date to the media.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

 void CCompFileCB::FlushAllL()

 //

 // Commit any buffered date to the media.

 //

 	{

 	User::Leave(KErrAccessDenied);

 	}

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

 	{

 	if (TrueFile())

 	return TrueFile()->GetInterface(aInterfaceId, aInterface, aInput);

 	else

 		return KErrNotSupported;

 	}

 CCompDirCB::CCompDirCB()

 //

 //

 //

 	{}

 CCompDirCB::~CCompDirCB()

 //

 //

 //

 	{

 	__PRINT1(_L("~CCompDirCB() [0x%x]"),this);

 	for(TInt dir=iDirs.Count(); dir--;)

 		{

 		if (iDirs[dir])

 			iDirs[dir]->Close();

 		}

 	iDirs.Close();

 	delete iMatch;

 	}

 void CCompDirCB::ReadL(TEntry& anEntry)

 //

 // Reads the next directory entry.

 //

 	{

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

 	if(Pending())

 		{

 		CDirCB* pDir = iDirs[iCurrentDir];

 		pDir->SetPending(ETrue);

 		TRAPD(r,pDir->ReadL(anEntry));

 		__ASSERT_ALWAYS(r!=KErrEof,Fault(ECompDirReadPending));

 		SetPending(pDir->Pending());

 		User::LeaveIfError(r);

 		return;

 		}

 	if(iCurrentDir < 0)

 		User::Leave(KErrEof);

 	TFileName match(*iMatch);

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

 	TPtrC dirName=match.Left(namePos);

 	TFileName filename;

 	TInt err;

 	do

 		{

 		CDirCB* theDir = iDirs[iCurrentDir];

 		if(theDir)

 			{

 			FOREVER // loop until we can read no more (EOF or other err)

 					// If non-duplicate entry found, it returns.

 				{

 				TRAP(err, theDir->ReadL(anEntry));

 				if(err != KErrNone)

 					break;

 				__PRINT2(_L("CCompDirCB:: ReadL got = '%S' from dir %d"),&anEntry.iName, iCurrentDir);

 				filename=dirName;

 				filename+=anEntry.iName;

 				if (!IsDuplicate(filename))

 					return;

 				}

 			// We have either reached EOF for CurrentDir or encounted an error.

 			__PRINT1(_L("CCompDirCB:: ReadL err = %d"),err);

 			if(err != KErrEof)

 				{

 				User::Leave(err);

 				}

 			}

 		}

 	while (iCurrentDir--);

 	User::Leave(KErrEof);

 	}

 TBool CCompDirCB::IsDuplicate(TFileName& aFilename)

 //

 // Is used by ReadL to determine if a file name read is a duplicate of

 // a filename already read bit it.

 //

 	{	

 	RArray<TCompMount>	&mounts = ((CCompMountCB*)&Mount())->iMounts;	

 	TInt count = mounts.Count();

 	TEntry tmpEntry;

 	__PRINT1(_L("theMount->iMounts.Count() = %d"),count);

 	for (TInt idx = iCurrentDir+1; idx < count; idx++)

 		{

 		TRAPD(r, mounts[idx].iMount->EntryL(aFilename,tmpEntry));

 		if ((r == KErrNone) || (r == KErrHidden) || (r == KErrPathHidden))

 			{

 			__PRINT1(_L("CCompDirCB:: Duplicate (r=%d)"),r);

 			return (ETrue);

 			}

 		}		

 	return (EFalse);

 	}

 void CCompDirCB::StoreLongEntryNameL(const TDesC& aName)

 //

 // Stores the Long Entry Name

 //

 	{

 	__ASSERT_ALWAYS(iCurrentDir >= 0 && iDirs[iCurrentDir] != NULL, Fault(ECompDirStoreLongEntryNameL));

 	iDirs[iCurrentDir]->StoreLongEntryNameL(aName);

 	}

 extern "C" {

 EXPORT_C CFileSystem* CreateFileSystem()

 //

 // Create a new file system

 //

 	{

 	return(CCompFileSystem::NewL());

 	}

 }