// 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;