// 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\sfile\sf_sys.cpp

// 

//

#include "sf_std.h"

#include <e32uid.h>

#include "sf_file_cache.h"

#include <kernel\localise.h>

#include <f32file.h>

typedef CFileSystem*(*TFileSystemNew)();

extern CProxyDriveFactory* GetExtension(const TDesC& aName);

#ifndef __WINS__

extern TBool gInitCacheCheckDrivesAndAddNotifications;

#endif

struct TFatUtilityFunctions;

GLREF_D TCodePageUtils TheCodePage;

const TInt KMaxLengthShortNameWithDot = 12;

const TUint8 KLeadingE5Replacement = 0x05;

const TUint8 KEntryErasedMarker=0xE5;           ///< Erased entry marker for a directory entry

/**

Default constructor.

*/

EXPORT_C CFileSystem::CFileSystem()

	{

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemConstructor, EF32TraceUidFileSys);

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemConstructorReturn, EF32TraceUidFileSys);

	}

/**

Destructor.

*/

EXPORT_C CFileSystem::~CFileSystem()

	{

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemDestructor, EF32TraceUidFileSys);

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemDestructorReturn, EF32TraceUidFileSys);

	}

/**

Uninstalls the file system.

This is called just before the file system object is destroyed, and allows

any clean up to be carried out.

The default implementation does nothing except return KErrNone.

Implementations should return an error code on error detection.

@return KErrNone if successful, otherwise one of the other system wide error

        codes.

*/

EXPORT_C TInt CFileSystem::Remove()

	{

	return(KErrNone);

	}

/**

Tests whether a version is supported.

This is done decided by comparing the supplied version with iVersion.

The default implementation uses User::QueryVersionSupported() to

determine this.

@param aVer The version to be tested.

@return True, if aVer is supported; false otherwise

@see User::QueryVersionSupported

@see CFileSystem::iVersion

*/

EXPORT_C TBool CFileSystem::QueryVersionSupported(const TVersion& aVer) const

	{

	return(User::QueryVersionSupported(iVersion,aVer));

	}

//#ifndef __DATA_CAGING__

/**

Retrieves the default path for the file system.

Each session with the file server has a current session path.

When a new session is opened, its session path is set to the default path

of the file server.

At file server start-up, this default path is set to the default path returned

by the local file system. 

The function should return an appropriate error code when the default path

cannot be supplied. 

The derived class should override this base class function.

This default implementation raises an "Fserv fault" 31 panic.

@param aPath On return, contains the default path for the file system for derived classes.

@return KErrNone if successful, otherwise one of the other system wide error codes.

@panic Fserv fault 31 if the default implementation

       for CFileSystem::DefaultPath() is not overridden. 

*/

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

	{

	Fault(ESysDefaultPathNotSupported);

	return(KErrNone);

	}

//#endif

/**

Sets the file system's resource library.

This library represents the loaded file system.

This is called internally by InstallFileSystem().

@param aLib The resource library to be set.

*/

EXPORT_C void CFileSystem::SetLibrary(RLibrary aLib)

	{

	iLibrary=aLib;

	}

/**

Gets the file system's resource library.

@return The file system's resource library.

*/

EXPORT_C RLibrary CFileSystem::Library() const

	{

	return(iLibrary);

	}

/**

Tests whether the file system supports extensions.

@return True, if the file system supports extensions, false otherwise.

        The defualt implementation returns false.

*/

EXPORT_C TBool CFileSystem::IsExtensionSupported() const

	{

	return(EFalse);

	}

EXPORT_C void CFileSystem::DriveInfo(TDriveInfo& aInfo, TInt aDriveNumber) const

	{

    GetDriveInfo(aInfo, aDriveNumber);

	}

EXPORT_C TInt CFileSystem::GetInterface(TInt /*aInterfaceId*/,TAny*& /*aInterface*/,TAny* /*aInput*/)

	{

	return(KErrNotSupported);

	}

EXPORT_C TBool CFileSystem::IsProxyDriveSupported()

	{

	TAny* dummyInterface;

	if(GetInterface(EProxyDriveSupport, dummyInterface, NULL) == KErrNone)

		return ETrue;

	return EFalse;

	}

//----------------------------------------------------------------------------- 

/** 

    Extended CMountCB factory interface.

    Produces the CMountCB object which can be associated with another CFileSystem owner.

    Used mostly  with "automounter" file system

    @param  apDrive         in:  pointer to TDrive, producing right CMountCB can require media access ("automounter" recognising the file system)

    @param  apFileSystem    out: pointer to the CFileSystem object that actually produced CMountCB instance (might be different from "this")

    @param  aForceMount     in:  ETrue if it is necessarily to force mounting (formatting the media, for example)

    @param  aFsNameHash     in:  desired file system name hash (optional). Specifies which file system will be used to produce appropriate CMountCB object.

                                 The file system that implements NewMountExL() shall decide how to process it. 0 means "default/not specified".

    @return pointer to the instantiated CMountCB object.

*/

CMountCB* CFileSystem::NewMountExL(TDrive* apDrive, CFileSystem** apFileSystem, TBool aForceMount, TUint32 aFsNameHash)

    {

    TAny* pa;

    if(GetInterface(EExtendedFunctionality, pa, NULL) == KErrNone)

        {//-- special interface for the case, when CMountCB object will be produced by not _this_ CFileSystem object, but some different.

         //-- in this case apFileSystem will contain a pointer to the real factory.

        MFileSystemExtInterface* pExtIf = (CFileSystem::MFileSystemExtInterface*)pa;

        ASSERT(pExtIf);

        return pExtIf->NewMountExL(apDrive, apFileSystem, aForceMount, aFsNameHash);

        }

    else

        {//--This interface is not supported by current CFileSystem implementation, call normal legacy factory method

         //-- and make _this_ object of CFileSystem produce a new CMountCB 

            ASSERT(aFsNameHash == 0); //-- it is impossible to specify the particular FS to be used

            *apFileSystem = this; 

            return NewMountL();

        }

    }

//----------------------------------------------------------------------------- 

/** 

    Get the name of a filesystem from the list of supported on this drive.

    Some filesystems (e.g. "automounter" can support more than one real "child" filesystems.

    For the normal case, only one filesystem is supported (a mouned one).

    @param  aFsNumber   used to enumerate supported filesystems can be:

                        special value KRootFileSystem, or

                        0,1,2... - the sequence number of a "child" FS.

    @param  aFsName     out: buffer for the returned file system name

    @return KErrNone        Ok, aFsName contains valid value for the given aFsNumber

            KErrNotFound    There is no supported filesystem for the given aFsNumber

*/

TInt CFileSystem::GetSupportedFileSystemName(TInt aFsNumber, TDes& aFsName) 

    {

    TAny* pa;

    //-- we need a special interface to find out the name of the supported file system number "aFsNumber"

    if(GetInterface(EExtendedFunctionality, pa, NULL) == KErrNone)

        {

        MFileSystemExtInterface* pExtIf = (CFileSystem::MFileSystemExtInterface*)pa;

        ASSERT(pExtIf);

        return pExtIf->GetSupportedFileSystemName(aFsNumber, aFsName);   

        }

    else

        {//--This interface is not supported by current CFileSystem implementation, but in this case "Root" and first "child" filesystem mean

         //-- the same and this is "this" filesystem

            if(aFsNumber == RFs::KRootFileSystem || aFsNumber == RFs::KFirstChildFileSystem)

                {

                aFsName = Name();

                return KErrNone;               

                }

            else

                {

                return KErrNotFound;

                }

        }

    }

//----------------------------------------------------------------------------- 

TInt InstallFileSystem(CFileSystem* aSys,RLibrary aLib)

//

// Install a file system.

//

	{

	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemInstall, EF32TraceUidFileSys, aSys);

	TInt r=aSys->Install();

	TRACERETMULT2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemInstallRet, EF32TraceUidFileSys, r, aSys->Name());

	__PRINT1TEMP(_L("InstallFileSystem %S"),aSys->Name());

	if (r==KErrNone)

		{TRAP(r,FileSystems->AddL(aSys,ETrue))}

	if (r!=KErrNone)

		{

		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemove, EF32TraceUidFileSys, aSys);

#ifdef SYMBIAN_FTRACE_ENABLE

		TInt r = 

#endif

			aSys->Remove();

		TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemoveRet, EF32TraceUidFileSys, r);

		}

	if (r==KErrNone)

		aSys->SetLibrary(aLib);

	else

		aSys->Close();

	return(r);

	}

EXPORT_C CFileSystem* GetFileSystem(const TDesC& aName)

//

// Lookup a file system by name.

//

	{

	TInt h=0;

	TInt r=FileSystems->FindByName(h,aName);

	if (r!=KErrNone)

		return(NULL);

	return((CFileSystem*)FileSystems->At(h));

	}

TInt TFsAddFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Add a file system.

//

	{

	__PRINT(_L("TFsAddFileSystem::DoRequestL(CFsRequest* aRequest)"));

	RLibrary lib;

	lib.SetHandle(aRequest->Message().Int0()); // Get library handle

	if (lib.Type()[1]!=TUid::Uid(KFileSystemUidValue))

		return KErrNotSupported;

	TFileSystemNew f=(TFileSystemNew)lib.Lookup(1);

	if (!f)

		return KErrCorrupt;

	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNew, EF32TraceUidFileSys, lib.Handle());

	CFileSystem* pS=(*f)();

	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewRet, EF32TraceUidFileSys, pS);

	if (!pS)

		return KErrNoMemory;

	TInt r=InstallFileSystem(pS,lib);

	if (r==KErrNone && !LocalFileSystemInitialized)

		{

		_LIT(KLocFSY, "ELOCAL.FSY");

		TFileName fn(lib.FileName());

		TParsePtrC ppc(fn);

		if (ppc.NameAndExt().CompareF(KLocFSY) == 0)

			r = InitializeLocalFileSystem(pS->Name());

		}

	return r;

	}

TInt TFsAddFileSystem::Initialise(CFsRequest* aRequest)

//

//

//

	{

	TSecurityPolicy policy(RProcess().SecureId(), ECapabilityTCB);

	if (!policy.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Add File System")))

		return KErrPermissionDenied;

	return KErrNone;

	}

TInt TFsRemoveFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Remove a file system.

//

	{

	TFullName name;

	aRequest->ReadL(KMsgPtr0,name);

	CFileSystem* pF=GetFileSystem(name);

	if (pF==NULL)

		return(KErrNotFound);

	CFileSystem* pFs = NULL;

	for(TInt drvNum=0; drvNum<KMaxDrives; drvNum++)

		{

		FsThreadManager::LockDrive(drvNum);

		pFs=TheDrives[drvNum].GetFSys();

		FsThreadManager::UnlockDrive(drvNum);

		if(!pFs)

			continue;

        if(name.CompareF(pFs->Name()) == 0)

			return KErrInUse;

		}

    TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemove, EF32TraceUidFileSys, pF);

	TInt r=pF->Remove();

	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemoveRet, EF32TraceUidFileSys, r);

	if (r!=KErrNone)

		return(r);

    RLibrary lib=pF->Library();

	pF->Close();

	lib.Close();

    return KErrNone;

	}

TInt TFsRemoveFileSystem::Initialise(CFsRequest* aRequest)

//

//

//

	{

	if (!KCapFsRemoveFileSystem.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Remove File System")))

		return KErrPermissionDenied;

	return KErrNone;

	}

LOCAL_C TInt DoMountFileSystem(CFsRequest* aRequest)

//

//

//

	{

	TInt r = TFileCacheSettings::ReadPropertiesFile(aRequest->Drive()->DriveNumber());

	if (r != KErrNone)

		return r;

	return(aRequest->Drive()->CheckMount());

	}

LOCAL_C TInt DoMountFsInitialise(CFsRequest* aRequest,TDesC& aFsName,TBool aIsExtension,TBool aIsSync)

//

//

//

	{

	if (!KCapFsMountFileSystem.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Mount File System")))

		return KErrPermissionDenied;

	TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);

	if(r!=KErrNone)

		return(r);

	TBool driveThreadExists = FsThreadManager::IsDriveAvailable(aRequest->DriveNumber(), ETrue);

	if(driveThreadExists)

		{

		// A drive thread already exists for this drive.This could be because a filesystem

		// is already mounted, or a proxy drive is loaded.  Check the mount to be sure...

		if(aRequest->Drive()->GetFSys())

			{

			// Yes, a mount already exists so we can't mount another one!

			return(KErrAccessDenied);

			}

		__ASSERT_DEBUG(IsProxyDrive(aRequest->DriveNumber()), User::Panic(_L("Bad thread state - No Mount or Proxy Drive Exists!"), -999));

		}

	// ...therefore no drive thread can be present

	__ASSERT_DEBUG(!&aRequest->Drive()->FSys(),Fault(EMountFileSystemFSys));

	if(aRequest->Drive()->IsSubsted())

		return(KErrAccessDenied);

	CFileSystem* pF = GetFileSystem(aFsName);

	if (pF == NULL)

		return(KErrNotFound);

	// Check that if the drive is a proxy drive (not using TBusLocalDrive) then the filesystem supports these...

	TInt driveNumber = aRequest->DriveNumber();

	if(IsProxyDrive(driveNumber))

		{

		if(!pF->IsProxyDriveSupported())

			return KErrNotSupported;

		r = LocalDrives::SetupMediaChange(driveNumber);

		}

	TDriveInfo driveInfo;

	driveInfo.iDriveAtt=0;

	pF->DriveInfo(driveInfo, driveNumber);

	if(!driveInfo.iDriveAtt)

		r = KErrArgument;

    if(r == KErrNone && !driveThreadExists)

	    {

    	// determine whether file system synchronous or not not by flag passed in

		r=FsThreadManager::InitDrive(driveNumber, aIsSync);

        }

	if(r!=KErrNone)

		return(r);

    //-- let TDrive object know if the drive is synchronous

	aRequest->Drive()->SetSynchronous(aIsSync);

    if(aIsExtension && aRequest->Message().Ptr2()!=NULL)

		{

		TFullName extName;

		r = aRequest->Read(KMsgPtr2,extName);

		if (r!=KErrNone)

			return r;

		CProxyDriveFactory* pE=GetExtension(extName);

		if(pE==NULL)

			return(KErrNotFound);

		r=aRequest->Drive()->MountExtension(pE,ETrue);

		if(r!=KErrNone)

			return(r);

		}

	TInt32 newAtt = 0;

	TInt32 oldAtt = 0;

	_LIT8( KAddAtt, "AddDriveAttributes");

	_LIT8( KRemoveAtt, "RemoveDriveAttributes");

	_LIT8( KLogicallyRemovableAtt, "KDRIVEATTLOGICALLYREMOVABLE");

	_LIT8( KHiddenAtt, "KDRIVEATTHIDDEN");

	_LIT8( KLogicallyRemovableAttHex, "0X200");

	_LIT8( KHiddenAttHex, "0X400");

	TBuf8<0x1000> addbuf;

	addbuf.FillZ();

	TBuf8<0x1000> removebuf;

	removebuf.FillZ();

	TInt drive = aRequest->Message().Int1();

	_LIT8(KLitSectionNameDrive,"Drive%C");

	TBuf8<8> sectionName;

	sectionName.Format(KLitSectionNameDrive, 'A' + drive);

	F32Properties::GetString(sectionName, KAddAtt, addbuf);

	F32Properties::GetString(sectionName, KRemoveAtt, removebuf);  //oldAtt now contains value of the attributes to be removed from iDriveAtt.

	if(addbuf.Length() != 0)

		{

		TInt pos = 0;

		TInt length = 0;

		TPtrC8 ptr;

		TBool endOfFlag=EFalse; 

		while(!endOfFlag)

		{

		ptr.Set(addbuf.Mid(pos));

		length = ptr.Locate(',');

		if(length == KErrNotFound)

			{

			endOfFlag = ETrue;

			} 

		else{

			ptr.Set(ptr.Left(length));

			pos += (length +1);

			}

		if(((ptr.MatchF(KLogicallyRemovableAtt)) != KErrNotFound) || ((ptr.MatchF(KLogicallyRemovableAttHex)) != KErrNotFound))

			newAtt |= KDriveAttLogicallyRemovable;

		if(((ptr.MatchF(KHiddenAtt)) != KErrNotFound)  || ((ptr.MatchF(KHiddenAttHex)) != KErrNotFound))

			newAtt |= KDriveAttHidden;

		}

		}

	if(removebuf.Length() != 0)

		{

		TInt pos = 0;

		TInt length = 0;

		TPtrC8 ptr;

		TBool endOfFlag=EFalse; 

		while(!endOfFlag)

		{

		ptr.Set(removebuf.Mid(pos));

		length = ptr.Locate(',');

		if(length == KErrNotFound)

			{

			endOfFlag = ETrue;

			} 

		else{

			ptr.Set(ptr.Left(length));

			pos += (length +1);

			}

		if(((ptr.MatchF(KLogicallyRemovableAtt)) != KErrNotFound) || ((ptr.MatchF(KLogicallyRemovableAttHex)) != KErrNotFound))

			oldAtt |= KDriveAttLogicallyRemovable;

		if(((ptr.MatchF(KHiddenAtt)) != KErrNotFound) || ((ptr.MatchF(KHiddenAttHex)) != KErrNotFound))

			oldAtt |= KDriveAttHidden;

		}

		}

	if ((newAtt & KDriveAttLogicallyRemovable) && (!(driveInfo.iDriveAtt & KDriveAttRemovable)) && (!(newAtt & KDriveAttRemovable)))

		{

		newAtt |= KDriveAttRemovable; 	//KDriveAttLogicallyRemovale should always set KDriveAttRemovale

		}

	if ((oldAtt & KDriveAttRemovable)  && (!(oldAtt & KDriveAttLogicallyRemovable)))

		{

		oldAtt |= KDriveAttLogicallyRemovable;

		}

	if(newAtt)

		{

		driveInfo.iDriveAtt |= newAtt;

		}

	if(oldAtt)

		{

		if(oldAtt & driveInfo.iDriveAtt)

			{

			driveInfo.iDriveAtt ^= oldAtt;  

			}

		}

	aRequest->Drive()->SetAtt(driveInfo.iDriveAtt);

	aRequest->Drive()->GetFSys()=pF;

	// empty the closed file queue

	TClosedFileUtils::Remove(aRequest->DriveNumber());

	return(KErrNone);

	}

TInt TFsMountFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Mount a filesystem on a drive.

//

	{

	TInt r=DoMountFileSystem(aRequest);

	if( KErrNone == r )

		{

		FsNotify::DiskChange(aRequest->DriveNumber());

		}

	// Refresh the loader cache to ensure that the new drive is monitored.

#ifndef __WINS__

	gInitCacheCheckDrivesAndAddNotifications = EFalse;

#endif 

	return r;

	}

TInt TFsMountFileSystem::Initialise(CFsRequest* aRequest)

//

//	

//

	{

	TFullName name;

	TInt r = aRequest->Read(KMsgPtr0,name);

	if (r == KErrNone)

		r = DoMountFsInitialise(aRequest,name,ETrue,aRequest->Message().Int3());

	return r;

	}

TInt TFsMountFileSystemScan::DoRequestL(CFsRequest* aRequest)

//

// mount file system and then call scandrive

//

	{

	TInt r=DoMountFileSystem(aRequest);

	// run scandrive if successful mount

	TBool isMountSuccess=(KErrNone==r);

	if(isMountSuccess)

		{

		r=aRequest->Drive()->ScanDrive();

		FsNotify::DiskChange(aRequest->DriveNumber());

		}

	TPtrC8 pMS((TUint8*)&isMountSuccess,sizeof(TBool));

	aRequest->WriteL(KMsgPtr3,pMS);

	return(r);

	}

TInt TFsMountFileSystemScan::Initialise(CFsRequest* aRequest)

//

//	

//

	{

	TFullName name;

	TInt r = aRequest->Read(KMsgPtr0,name);

	if (r == KErrNone)

		r = DoMountFsInitialise(aRequest,name,ETrue,EFalse);

	return r;

	}

LOCAL_C TInt DoDismountFileSystem(const TDesC& aName, TDrive* aDrive, TBool aAllowRom, TBool aForceDismount)

//

// Do file system dismount

//

	{

	TInt drvNumber=aDrive->DriveNumber();

	FsThreadManager::LockDrive(drvNumber);

	CFileSystem* pF=GetFileSystem(aName);

	if(pF==NULL)

		{

		FsThreadManager::UnlockDrive(drvNumber);

		return(KErrNotFound);

		}

	if(aDrive->IsRom() && !aAllowRom)

		{

		FsThreadManager::UnlockDrive(drvNumber);

		return(KErrAccessDenied);

		}

	if(!aForceDismount)

		{

		if(aDrive->IsMounted() && aDrive->CurrentMount().LockStatus()!=0)

			{

			FsThreadManager::UnlockDrive(drvNumber);

			return(KErrInUse);

			}

		if(aDrive->ActiveMounts() > 1)

			{

			FsThreadManager::UnlockDrive(drvNumber);

			return(KErrInUse);

			}

		aDrive->ReactivateMounts();

		}

	// ensure that current mount is dismounted

	if(aForceDismount)

		{

		TInt r = aDrive->FlushCachedFileInfo(ETrue);

		// Dismount the file system even if the flush fails for some reason (media permanently removed, user cancels notifier etc

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

			{

			FsThreadManager::UnlockDrive(drvNumber);

			return(r);

			}

		aDrive->ForceDismount();

		}

	else

		{

		aDrive->Dismount();

		}

	aDrive->GetFSys()=NULL;

	aDrive->SetAtt(0);

	aDrive->ExtInfo().iCount=0;

	// no need to cancel requests if synchronous since queued

	if(!FsThreadManager::IsDriveSync(drvNumber,EFalse))

		{

		CDriveThread* pT=NULL;

		TInt r=FsThreadManager::GetDriveThread(drvNumber,&pT);

		__ASSERT_ALWAYS(r==KErrNone && pT,Fault(EDismountFsDriveThread));

		pT->CompleteAllRequests(KErrNotReady);

		}

	if(!IsProxyDrive(drvNumber))

		{

		// Proxy drives are responsible for managing the drive threads...

		FsThreadManager::CloseDrive(drvNumber);

		}

	FsThreadManager::UnlockDrive(drvNumber);

	FsNotify::DiskChange(drvNumber);

	return(KErrNone);

	}

TInt TFsDismountFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Dismount a filesystem from a drive.

//

	{

	TDrive* drive=aRequest->Drive();

	__ASSERT_DEBUG(&aRequest->Drive()->FSys() && !drive->IsSubsted(),Fault(EDisMountFileSystemFSys));

	TFullName name;

	aRequest->ReadL(KMsgPtr0,name);

	if(drive->DismountDeferred())

		return KErrInUse;

	return DoDismountFileSystem(name, drive, EFalse, EFalse);

	}

TInt TFsDismountFileSystem::Initialise(CFsRequest* aRequest)

//

//	

//

	{

	if (!KCapFsDismountFileSystem.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Dismount File System")))

		return KErrPermissionDenied;

	TInt r = ValidateDrive(aRequest->Message().Int1(),aRequest);

	if(r == KErrNone)

		{

		TInt driveNumber = aRequest->DriveNumber();

		if(IsProxyDrive(driveNumber))

			{

			LocalDrives::NotifyChangeCancel(driveNumber);

			}

		}

	return r;

	}

/**

    Return name of file system mounted on a specified drive or one of the file system names if 

    the drive supports several of them.

*/

TInt TFsFileSystemName::DoRequestL(CFsRequest* aRequest)

	{

	//-- ipc parameters: 

    //-- 0 out: file system name decriptor

    //-- 1 drive number

    //-- 2 file system enumerator 

    const TInt driveNumber = aRequest->Message().Int1();

	if (driveNumber < 0 || driveNumber >= KMaxDrives)

		return KErrArgument;

    const TInt fsNumber = aRequest->Message().Int2(); //-- file system number; for RFs::FileSystemName() it is "-1"

    TFullName fsName;

	// lock drive to synchronise with dismounting a file system

	FsThreadManager::LockDrive(driveNumber);

	CFileSystem* pF=TheDrives[driveNumber].GetFSys();

	FsThreadManager::UnlockDrive(driveNumber);

    TInt err = KErrNone;

    if(pF)

        {

		if(fsNumber == -1)

            fsName = pF->Name(); //-- this is RFs::FileSystemName() call

        else

            err = pF->GetSupportedFileSystemName(fsNumber, fsName); //-- this is RFs::SupportedFileSystemName() call

	    }

	else

		{//-- the drive doesn't have file system installed

        fsName=_L("");

		err = KErrNotFound;

	    }

    aRequest->WriteL(KMsgPtr0, fsName);

    return err;

	}

TInt TFsFileSystemName::Initialise(CFsRequest* /*aRequest*/)

	{

	return KErrNone;

	}

TInt TFsRemountDrive::DoRequestL(CFsRequest* aRequest)

//

// Force a remount of the specified drive

//

	{	

	const TDesC8 *mountInfo=REINTERPRET_CAST(const TDesC8*,aRequest->Message().Ptr1());

	return(aRequest->Drive()->ForceRemountDrive(mountInfo,aRequest->Message().Handle(),aRequest->Message().Int2()));//changed from thread to message handle

	}

TInt TFsRemountDrive::Initialise(CFsRequest* aRequest)

//

//	

//

	{

	TInt r=ValidateDriveDoSubst(aRequest->Message().Int0(),aRequest);

	return(r);

	}

TInt TFsSetLocalDriveMapping::DoRequestL(CFsRequest* aRequest)

//

// set up drive letter to local drive mapping

//

	{

	return(LocalDrives::SetDriveMappingL(aRequest));

	}

TInt TFsSetLocalDriveMapping::Initialise(CFsRequest* /*aRequest*/)

//

//

//

	{

	return KErrNone;

	}

_LIT(KCompositeFsName,"Composite");

TInt TFsSwapFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Swap a filesystem on a drive

// Should always leave a filesystem mounted on the drive

//

	{

	TFileName newName;

	aRequest->ReadL(KMsgPtr0,newName);										

	CFileSystem* pF=GetFileSystem(newName);												

	if (pF==NULL)															

		return(KErrNotFound);

	TFileName oldName;			

	aRequest->ReadL(KMsgPtr2,oldName);										

	TInt drvNumber=aRequest->Message().Int1();	

	TBool newFsIsComposite = (newName.CompareF(KCompositeFsName) == 0);	

	if (newFsIsComposite)

		{

		if(CompFsMounted)

			return(KErrAlreadyExists);

		if(EDriveZ!=drvNumber)

			return(KErrNotSupported);

		}	

	else

		 // swapping filesystem on z: only allow for romfs + compfs

		if(EDriveZ==drvNumber)

			return(KErrNotSupported);

	TDrive& drive=TheDrives[drvNumber];

	if(drive.DismountDeferred())

		return KErrInUse;

	TBool clamps=drive.ClampFlag();

	if(clamps)

		return KErrInUse;

	// Return an error if the drive is asynchronous.

	// This function is only supported on synchronous drives.

	TBool isSync = FsThreadManager::IsDriveSync(drvNumber,EFalse);

	if(!isSync)

		return KErrNotSupported;

	TInt r=DoDismountFileSystem(oldName,&drive,ETrue,EFalse);

	if(r!=KErrNone)

		return(r);

	__ASSERT_ALWAYS(drive.GetFSys()==NULL,Fault(ESwapFileSystemNull));

	r=DoMountFsInitialise(aRequest,newName,EFalse,isSync);

	if(r==KErrNone)

		r=DoMountFileSystem(aRequest);

	if(drive.GetFSys()==NULL || (newFsIsComposite && r!=KErrNone)) 

		{

		// remounting of the original filesystem should not fail

		if(drive.GetFSys()!=NULL)

			r=DoDismountFileSystem(newName,&drive,ETrue,EFalse);

		r=DoMountFsInitialise(aRequest,oldName,EFalse,isSync);

		if(r==KErrNone)

			r=DoMountFileSystem(aRequest);

		__ASSERT_ALWAYS(r==KErrNone && drive.GetFSys()!=NULL,Fault(ESwapFileSystemMount));

		}

	else if (newFsIsComposite)

		{

		FsThreadManager::ChangeSync(drvNumber,CompFsSync);

		CompFsMounted=ETrue;

		}

	if(drvNumber==EDriveZ)

		{

		__ASSERT_ALWAYS(r==KErrNone,Fault(ESwapFileSystemRom));

		RefreshZDriveCache=ETrue;

		}

	return(r);

	}

TInt TFsSwapFileSystem::Initialise(CFsRequest* /*aRequest*/)

//

//	

//

	{

	return KErrNone;

	}	

TInt TFsAddCompositeMount::DoRequestL(CFsRequest* aRequest)

//

// Input fsyName, localDriveNUmber, CompositeDriveNumber

// 

//

	{

	__PRINT(_L("TFsAddCompositeMount::DoRequestL"));

	TFileName fsyName;

	aRequest->ReadL(KMsgPtr0,fsyName);										

	CFileSystem* pNewFileSystem=GetFileSystem(fsyName);

	if (pNewFileSystem==NULL)

		return KErrNotFound;

	const TInt localDriveNumber=aRequest->Message().Int1();								

	const TInt compositeDriveNumber=aRequest->Message().Int2();

	const TInt sync=aRequest->Message().Int3();									

    __PRINT3(_L("TFsAddCompositeMount::DoRequestL fsy:%S, locDrv:%d, compDrv:%d"),&fsyName, localDriveNumber,compositeDriveNumber);

	// Currently, compFS assumed its mounting on romfs, on z:

	if (compositeDriveNumber!=EDriveZ)

		return KErrNotSupported;

	// Mounts can only be added to the compfs, before it is mounted.

	if (CompFsMounted)

		return KErrInUse;

	// The drive is needed, so the new sub mount, can be mounted

	// on it temporarily.  ROMFS doest care if we do this as it

	// has no local mapping.

	FsThreadManager::LockDrive(compositeDriveNumber);

	TRAPD(err, AddFsToCompositeMountL(compositeDriveNumber, *pNewFileSystem, localDriveNumber));

	if (err!=KErrNone)

		{

		FsThreadManager::UnlockDrive(compositeDriveNumber);

		return err;

		}

//		Fault(EMountFileSystemFSys);

	FsThreadManager::UnlockDrive(compositeDriveNumber);

	// The drive will end up asynchronous if any sub mounts are.

	if (!sync)

		CompFsSync=EFalse;