// 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_svr.cpp

 // 

 //

 #include "sf_std.h"

 #include "sf_cache_man.h"

 #include "sf_file_cache.h"

 #include "sf_memory_man.h"

 TInt DoFsSubClose(CFsRequest* aRequest)

 //

 // Close a subsession.

 //

 	{

 	const TInt handle(aRequest->Message().Int3());

 	CFsObject* pO=SessionObjectFromHandle(handle,0,aRequest->Session());

 	if(!pO)

 		return KErrBadHandle;

 	aRequest->Session()->DecResourceCount();

 	aRequest->Session()->Handles().Remove(handle,ETrue);

 	// this request has also opened this object, so close it here before it 

 	// gets to a plugin as a plugin may attempt to open the file/dir itself

 	aRequest->SetScratchValue64( MAKE_TUINT64(I64HIGH(aRequest->ScratchValue64()), 0));

 	return(KErrNone);

 	}

 TInt TFsSubClose::DoRequestL(CFsRequest* aRequest)

 //

 // Close a subsession.

 //

 	{

 	// Leave and then panic client with KErrBadHandle if necessary.

 	CFsObject* pO = SessionObjectFromHandle(aRequest->Message().Int3(),0,aRequest->Session());

 	if(!pO)

 		return KErrBadHandle;

 	if(aRequest->Message().Function() == EFsFileSubClose)

 		{

 		CFileShare* pShare = (CFileShare*) aRequest->ScratchValue();

 		// flush the file cache

 		CFileCache* fileCache = pShare->File().FileCache();

 		if (fileCache && fileCache->FlushDirty(aRequest) == CFsRequest::EReqActionBusy)

 			return CFsRequest::EReqActionBusy;

 		// if any write requests are being fair scheduled, wait for them to complete

 		if (pShare->RequestInProgress())

 			return CFsRequest::EReqActionBusy;

 		}

 	return DoFsSubClose(aRequest);

 	}

 TInt TFsSubClose::Initialise(CFsRequest* aRequest)

 //

 //	Now moved to RequestAllocator::GetRequest 

 //

 	{

 	TInt r = KErrNone;

 	// Closing a file share may require flushing of dirty data, so deal with this in the drive thread

 	// in TFsSubClose::DoRequestL(). For other objects (EFsFormatSubClose, EFsDirSubClose, EFsRawSubClose,

 	// FsPluginSubClose) we may complete the message here.

 	if(aRequest->FsFunction() == EFsFileSubClose)

 		{

 		CFileShare* pShare = (CFileShare*)

 			SessionObjectFromHandle(aRequest->Message().Int3(), FileShares->UniqueID(), aRequest->Session());

 		if(!pShare)

 			User::Leave(KErrBadHandle);

 		HBufC* pFileName = pShare->File().FileName().Alloc();

 		aRequest->SetScratchValue64( MAKE_TUINT64((TUint) pFileName, (TUint) pShare) );

 		TInt driveNumber = pShare->File().Drive().DriveNumber();

 		aRequest->SetDriveNumber(driveNumber);

 		}

 	// Define a completion routine so that we can see whether this request is cancelled - 

 	// if it is we still want to close the subsession (but not bother about flushing dirty data)

 	r = ((CFsMessageRequest*) aRequest)->PushOperation(TFsSubClose::Complete);

 	return r;

 	}

 TInt TFsSubClose::Complete(CFsRequest* aRequest)

 	{

 	// if LastError() != KErrNone, this implies the request has been cancelled. 

 	// i.e. TFsSubClose::DoRequestL() has not been called, so we need to call DoFsSubClose() here

 	if (((CFsMessageRequest*) aRequest)->LastError() != KErrNone)

 		DoFsSubClose(aRequest);

 	return CFsRequest::EReqActionComplete;

 	}

 TInt TFsNotifyChange::DoRequestL(CFsRequest* aRequest)

 //

 //

 //

 	{

 	CStdChangeInfo* notificationInfo=new CStdChangeInfo;

 	if (notificationInfo==NULL)

 		return (KErrNoMemory);

 	const RMessage2& m=aRequest->Message();

 	notificationInfo->Initialise((TNotifyType)m.Int0(),(TRequestStatus*)m.Ptr1(),m,aRequest->Session());

 	TInt r=FsNotify::AddChange(notificationInfo,KDriveInvalid);

 	if(r!=KErrNone)

 		delete(notificationInfo);

 	return(r);

 	}

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

 //

 //

 //

 	{

 	return(KErrNone);

 	}

 TInt TFsNotifyChangeEx::DoRequestL(CFsRequest* aRequest)

 //

 //	Set up an extended change notification

 //

 	{

 	TUint notifyType=aRequest->Message().Int0();

 	if (aRequest->Src().NamePresent())	//	Monitoring a file

 		{								//	Reject if iNotifyType is ENotifyDir

 		if (notifyType&ENotifyDir)

 			return (KErrArgument);

 		}

 	CExtChangeInfo* notificationInfo=new CExtChangeInfo;

 	if (notificationInfo==NULL)

 		return (KErrNoMemory);

 /*	TEntry t;

 	TInt ret=aRequest->Drive()->Entry(aRequest->Src().FullName().Mid(2),t);

 	if ((ret==KErrNotFound)||(ret==KErrPathNotFound)||(ret==KErrInUse))			

 	//	Path does not yet exist or drive has been locked - still submit request

 	//	but mark it as notify all since the client is potentially interested

 		notifyType=ENotifyAll;	

 	else if (ret!=KErrNone)		

 		{

 		delete notificationInfo;

 		return(ret);

 		}*/

 	const RMessage2& m=aRequest->Message();

 	notificationInfo->Initialise((TNotifyType)notifyType,(TRequestStatus*)m.Ptr2(),m,aRequest->Session(),aRequest->Src().FullName().Mid(2));

 	TInt drive;

 	if (aRequest->ScratchValue()!=0)

 		drive=KDriveInvalid;

 	else

 		drive=aRequest->DriveNumber();

 	TInt ret=FsNotify::AddChange(notificationInfo,drive);

 	if(ret!=KErrNone)

 		delete(notificationInfo);

 	return(ret);

 	}

 TInt TFsNotifyChangeEx::Initialise(CFsRequest* aRequest)

 	{

 	//	Establish whether the directory or file to watch actually exists

 	//	This sets the aSession members iTheName and iTheParse etc

 	TInt ret=KErrNone;

 	TBool monitorAllDrives=EFalse;

 	TFileName notifyPath;

 	TRAP(ret,aRequest->ReadL(KMsgPtr1,notifyPath));

 	if(ret!=KErrNone)

 		return(ret);

 	if(notifyPath.Length()==0)

 		return(KErrArgument);

 	if ((notifyPath[0]==KMatchAny)||(notifyPath[0]==KMatchOne))

 		{

 	//	Use the default session drive for now

 	//	Client has submitted a ? or * for drive

 		monitorAllDrives=ETrue;

 		ret=ParseNotificationPath(aRequest,aRequest->Src(),notifyPath);

 		if (ret!=KErrNone)

 			return(ret);

 		}

 	else

 		{

 	//	Client has submitted a single drive to monitor

 		monitorAllDrives=EFalse;

 	    ret = ParseNoWildSubstPtr1(aRequest, aRequest->Src());

 		if (ret!=KErrNone)

 			return(ret);

 		}

 	aRequest->SetScratchValue(monitorAllDrives);

 	ret = PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsNotifyChangeEx, __PLATSEC_DIAGNOSTIC_STRING("Extended Change Notifier"));		

 	return(ret);

 	}

 TInt TFsNotifyChangeCancel::DoRequestL(CFsRequest* aRequest)

 //

 //

 //

 	{

 	FsNotify::CancelChangeSession(aRequest->Session());

 #if defined(_DEBUG)

 	FsNotify::CancelDebugSession(aRequest->Session());

 #endif

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsNotifyChangeCancelEx::DoRequestL(CFsRequest* aRequest)

 //

 //

 //

 	{

 	FsNotify::CancelChangeSession(aRequest->Session(),(TRequestStatus*)aRequest->Message().Ptr0());

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 	FsNotify::CancelDebugSession(aRequest->Session());

 #endif

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 //

 // Setup a disk space notification request

 //

 TInt TFsNotifyDiskSpace::DoRequestL(CFsRequest *aRequest)

 	{

 	//-- first check that the threshold value is correct and is less than the volume size

     const TUint64 threshold = aRequest->ScratchValue64();

     if(threshold <= 0)

         return KErrArgument;

     //-- get the size of the mounted volume to check that the requested threshold isn't larger than the volume

     TUint64 volSz;

     TInt r = aRequest->Drive()->MountedVolumeSize(volSz);

 	if (r!=KErrNone)

 		return r;

     if(threshold >= volSz)

         return KErrArgument;

     //-- Create the disk space notificator object and append it to the FsNotify queue

 	CDiskSpaceInfo* info=new CDiskSpaceInfo;

 	if(info==NULL)

 		return(KErrNoMemory);

 	const RMessage2& m=aRequest->Message();

 	info->Initialise((TRequestStatus*)m.Ptr2(),m,aRequest->Session(),threshold);

 	r=FsNotify::AddDiskSpace(info,aRequest->DriveNumber());

 	if(r!=KErrNone)

 		delete info;

 	return(r);

 	}

 TInt TFsNotifyDiskSpace::Initialise(CFsRequest *aRequest)

 //

 //

 //

 	{

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

 	if (r==KErrNone)

 		{

 		TInt64 threshold;

 		TPtr8 tBuf((TUint8*)&threshold,sizeof(TInt64));

 		aRequest->ReadL(KMsgPtr0,tBuf);

 		aRequest->SetScratchValue64(threshold);

 		}

 	return(r);

 	}

 TInt TFsNotifyDiskSpaceCancel::DoRequestL(CFsRequest *aRequest)

 //

 // Cancel disk space notification

 //

 	{

 	FsNotify::CancelDiskSpaceSession(aRequest->Session(),(TRequestStatus*)aRequest->Message().Ptr0());

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return(KErrNone);

 	}

 TInt TFsSynchroniseDriveThread::DoRequestL(CFsRequest* /*aRequest*/)

 //

 // This is to ensure that previous message has been handled in drive thread. 

 //

 	{

 	return CFsRequest::EReqActionComplete;

 	}

 TInt TFsSynchroniseDriveThread::Initialise(CFsRequest *aRequest)

 //

 // Set the drive thread.

 //

 	{

 	if(aRequest->Message().Int0() == -1) //If no drive thread then complete the message

 		{

 	    return CFsRequest::EReqActionComplete;

   		}

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

 	return r;

 	}

 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)

 EXPORT_C void DebugNotifySessions(TInt aFunction,TInt /*aDrive*/)

 //

 //	Notify sessions of a debug event

 //

     {

 	// Notifying involves memory de-allocation on the file server's heap -

 	// check if we need to switch heaps.

 	RAllocator* current_alloc = &User::Heap();

 	RAllocator* svr_alloc = ServerThreadAllocator;

 	if (current_alloc != svr_alloc)

 		User::SwitchHeap(svr_alloc);

 	FsNotify::HandleDebug(aFunction);

 	if (current_alloc != svr_alloc)

 		User::SwitchHeap(current_alloc);

     }

 #else

 EXPORT_C void DebugNotifySessions(TInt,TInt)

 //

 //	Notify sessions of a debug event

 //

     {}

 #endif

 TInt TFsDriveList::DoRequestL(CFsRequest* aRequest)

 //

 // Get the current drive list.

 //

 	{

 	TDriveList list(KMaxDrives);

 	const TUint mask = (TUint) aRequest->Message().Int1();

 	const TUint matchedFlags=  mask & KDriveAttMatchedFlags;  //KDriveAttMatchedFlags = 0xFFF

 	const TUint matchedAtt = mask & KDriveAttMatchedAtt;	 //KDriveAttMatchedAtt = 0x0FFF0000

 	TInt r = ValidateMatchMask(mask);

 	if(r!=KErrNone) 

 	 	return r;

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

 		{

 		if(RFs::IsValidDrive(i))

 			{

 			const TUint driveAtt= TheDrives[i].Att();

 			if(matchedFlags != 0 )

 				{

 				switch(matchedAtt)

 					{

 					case KDriveAttExclude :

 						{

 						list[i]= (driveAtt & matchedFlags ) ? (TUint8)0:(TUint8)driveAtt ;

 						break;

 						}

 					case 0:

 						{

 						list[i] = (driveAtt & matchedFlags) ? (TUint8)driveAtt:(TUint8)0 ;

 						break;

 						}

 					case KDriveAttExclusive :

 						{

 						if(matchedFlags != KDriveAttLogicallyRemovable)

 							{

 							list[i] = ((TUint8)driveAtt == matchedFlags)  ? (TUint8)driveAtt:(TUint8)0;

 							}

 						else 

 							{

 							list[i] = (driveAtt == (matchedFlags | KDriveAttRemovable))  ? (TUint8)driveAtt:(TUint8)0;

 							}						

 						break;

 						}

 					case KDriveAttExclude | KDriveAttExclusive:

 						{

 						if(matchedFlags != KDriveAttLogicallyRemovable)

 							{

 							list[i] = ((TUint8)driveAtt == matchedFlags)  ?(TUint8)0:(TUint8)driveAtt;

 							}

 						else 

 							{

 							list[i] = (driveAtt == (matchedFlags | KDriveAttRemovable))  ? (TUint8)driveAtt:(TUint8)0;

 							}

 						break;

 						}

 					default:

 						{

 						return KErrArgument;

 						}

 					}

 				}

 			else  //matchedFlags == 0

 				{

 				switch(matchedAtt)

 					{

 					case 0:

 						list[i] = (TUint8)0 ;

 						break;

 					case KDriveAttAll:

 						list[i]= (TUint8)driveAtt;

 						break;

 					default:   //all other cases are incorrect

 						return KErrArgument;				

 					}

 				}

 			}

 		else //r!=KErrNone

 			{

 			list[i]=0;

 			}			

 		}

 	aRequest->WriteL(KMsgPtr0,list);

 	// Finally, kick off a speculative probe for devices

 	ProxyDrives->Lock();

 	TInt idx = ProxyDrives->Count();

 	while(idx--)

 		{

 		CExtProxyDriveFactory* pF = (CExtProxyDriveFactory*)(*ProxyDrives)[idx];

 		if(pF)

 			{

 			pF->AsyncEnumerate();

 			}

 		}

 	ProxyDrives->Unlock();

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsDrive::DoRequestL(CFsRequest* aRequest)

 //

 // Get drive info.

 //

 	{

 	// executed in main thread, therefore lock to ensure that

 	// dismount cannot occur during request

 	FsThreadManager::LockDrive(aRequest->DriveNumber());

 	TDriveInfo info;

 	aRequest->Drive()->DriveInfo(info);

 	if(aRequest->SubstedDrive())

 		info.iDriveAtt=KDriveAttSubsted;

 	FsThreadManager::UnlockDrive(aRequest->DriveNumber());

 	TPckgC<TDriveInfo> pInfo(info);

 	aRequest->WriteL(KMsgPtr0,pInfo);

 	return(KErrNone);

 	}

 TInt TFsDrive::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

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

 	return(r);

 	}

 /**

     Get volume info.

 */

 TInt TFsVolume::DoRequestL(CFsRequest* aRequest)

 	{

 	TVolumeInfo v;

     TPckg<TVolumeInfo> pV(v);

     //-- read TVolumeInfo from the client side, the client may have provided some data to pass to the server and FSY side

     aRequest->ReadL(KMsgPtr0,pV);

     TRequestStatus* pStat = (TRequestStatus*)aRequest->Message().Ptr2();

     if(pStat)

         {//-- the user called an asynchronous version of the RFs::Volume

          //-- indicate that we request free space asynchronously by setting a special flag that we will pass to the FSY

         v.iVolSizeAsync = ETrue;

         //-- at present the user's request will be completed by file server as the result of TFsVolume operation.

         }

     else

         {

         v.iVolSizeAsync = EFalse;    

         }

     //-- ask the FSY to provide us its volume information

     TInt r=aRequest->Drive()->Volume(v);

     CSessionFs* session=aRequest->Session();

 	if (r==KErrNone)

 		{

 		TDrive* drive = aRequest->Drive();

         const TInt driveNumber = drive->DriveNumber();

         if(!session->ReservedAccess(driveNumber))

 		    {

         	const TInt reserve = drive->ReservedSpace();

             if(v.iFree <= reserve)

                 v.iFree = 0;

             else

                 v.iFree -= reserve;

             }

 		if(aRequest->SubstedDrive())

 			v.iDrive.iDriveAtt=KDriveAttSubsted;

         if (drive->IsMounted() && drive->CurrentMount().LocalBufferSupport() == KErrNone && CCacheManagerFactory::CacheManager() != NULL)

 			v.iFileCacheFlags = TFileCacheSettings::Flags(driveNumber);

 		else

 			v.iFileCacheFlags = TFileCacheFlags(0);

 		aRequest->WriteL(KMsgPtr0,pV);

 		}

     return(r);

 	}

 TInt TFsVolume::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

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

 	return(r);

 	}

 TInt TFsSetVolume::DoRequestL(CFsRequest* aRequest)

 //

 // Set the volume name.

 //

 	{

     TInt r = CheckDiskSpace(0, aRequest);

     if(r != KErrNone)

         return r;

 	TFileName volumeName;

 	aRequest->ReadL(KMsgPtr0,volumeName);

 	if (volumeName.Length()>KMaxVolumeNameLength)	//	KMaxVolumeNameLength = 11 

 		return(KErrBadName);

     //	Validate name - return KErrBadName if it contains illegal characters such as * ? / | > <

 	TNameChecker checker(volumeName);

 	TText badChar;

 	if (checker.IsIllegalName(badChar))

 		return(KErrBadName);

 	return(aRequest->Drive()->SetVolume(volumeName));

 	}

 TInt TFsSetVolume::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

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

 	if (r!=KErrNone)

 		return(r);

 	if (!KCapFsSetVolume.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Set Volume")))

 		return KErrPermissionDenied;

 	return KErrNone;

 	}

 TInt TFsSubst::DoRequestL(CFsRequest* aRequest)

 //

 // Get a drive substitution.

 //

 	{

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

 	if(r!=KErrNone)

 		return(r);

 	TFileName substName;

 	__PRINT(_L("aRequest->Drive()->Att()&KDriveAttSubsted"));

 	__PRINT1(_L("aRequest->Drive()->Subst()"),&aRequest->Drive()->Subst());

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

 		substName=aRequest->Drive()->Subst();

 	aRequest->WriteL(KMsgPtr0,substName);

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsSetSubst::DoRequestL(CFsRequest* aRequest)

 //

 // Set a drive substitution.

 //

 	{

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

 	if (r!=KErrNone)

 		return(r);

 	TDrive* pD=aRequest->Drive();

 	r=ParsePathPtr0(aRequest,aRequest->Src());

 	if (r!=KErrNone)

 		return(r);

 	//TODO: no protection for unsubsting drives (could check substed path if system then only CRoot process can unsubst

 	if (pD->IsSubsted() && !aRequest->Src().DrivePresent() && !aRequest->Src().PathPresent())

 		{

 		delete &pD->Subst();

 		pD->SetSubst(NULL);

 		pD->SetAtt(0);

 		pD->SetSubstedDrive(NULL);

 		return(KErrNone);

 		}

 	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysSetSubst,&KCapFsPriSetSubst,&KCapFsROSetSubst, __PLATSEC_DIAGNOSTIC_STRING("Set Subst"));

 	if (r!=KErrNone)

 		return(r);

 	if (pD->Att()&(KDriveAttLocal|KDriveAttRom|KDriveAttRedirected|KDriveAttSubsted))

 		return(KErrGeneral);

 	if (pD==aRequest->Drive())

 		return(KErrGeneral);

 	if (aRequest->Drive()->Att()&(KDriveAttRedirected|KDriveAttSubsted))

 		return(KErrInUse);

 	HBufC* pS=aRequest->Src().FullName().Alloc();

 	if (pS==NULL)

 		return(KErrNoMemory);

 	__ASSERT_DEBUG(!&pD->SubstedDrive(),Fault(ETFsSetSubstNotNull));

 	delete &pD->Subst();

 	pD->SetSubst(pS);

 	pD->SetSubstedDrive(aRequest->Drive());

 	pD->SetAtt(KDriveAttSubsted);

 	return(KErrNone);

 	}

 TInt TFsSetSubst::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	if (!KCapFsSetSubst.CheckPolicy(aRequest->Message(),__PLATSEC_DIAGNOSTIC_STRING("Set subst")))

 	    return KErrPermissionDenied;

 	return KErrNone;

 	}

 TInt TFsRealName::DoRequestL(CFsRequest* aRequest)

 //

 // Get the real name of a file.

 //

 	{

 	TInt r=ParseSubstPtr0(aRequest,aRequest->Src());

 	if (r!=KErrNone)

 		return(r);

 	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysRealName,&KCapFsPriRealName, __PLATSEC_DIAGNOSTIC_STRING("Real Name"));

 	if (r!=KErrNone)

 		return(r);

 	TFileName substName;

 	if (aRequest->Drive()->Att()&KDriveAttRedirected)

 		substName=aRequest->Drive()->Subst();	//	DANGER?

 	else

 		substName=aRequest->Src().Drive();

 	if ((substName.Length()+aRequest->Src().FullName().Mid(2).Length())>KMaxFileName)

 		return(KErrBadName);

 	substName+=aRequest->Src().FullName().Mid(2);

 	aRequest->WriteL(KMsgPtr1,substName);

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsDefaultPath::DoRequestL(CFsRequest* aRequest)

 //

 // Get the default path.

 //

 	{

 	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement))

 		return KErrNotSupported;

 	else if(PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics))

 		{

 		//FIXME: to be remove the following when platform is fully secure

 		RThread tT;

 		TInt r=aRequest->Message().Client(tT,EOwnerThread);

 		if(r!=KErrNone)

 			return r;

 		RProcess tP;

 		r=tT.Process(tP);

 		if(r!=KErrNone)	

 			{

 			tT.Close();	

 			return r;

 			}

 		TName n;

 		n=tP.Name();

 		TInt b=n.Locate('[');

 		if (b>=0)

 			n.SetLength(b);

 		RDebug::Print(_L("**** API violation: %S should not use DefaultPath()\n"),&n);

 		tP.Close();

 		tT.Close();

 		//FIXME END

 		aRequest->WriteL(KMsgPtr0,TheDefaultPath);

 		return(KErrNone);

 		}

 	else

 		{

 		aRequest->WriteL(KMsgPtr0,TheDefaultPath);

 		return(KErrNone);

 		}

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsSetDefaultPath::DoRequestL(CFsRequest* aRequest)

 //

 // Set the default path.

 //

 	{

 	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement))

 		return KErrNotSupported;

 	else if(PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics))

 		{

 		//FIXME: to be remove the following when platform is fully secure

 		RThread tT;

 		TInt r=aRequest->Message().Client(tT,EOwnerThread);

 		if(r!=KErrNone)

 			return r;

 		RProcess tP;

 		r=tT.Process(tP);

 		if(r!=KErrNone)	

 			{

 			tT.Close();	

 			return r;

 			}

 		TName n;

 		n=tP.Name();

 		TInt b=n.Locate('[');

 		if (b>=0)

 			n.SetLength(b);

 		RDebug::Print(_L("**** API violation: %S should not use SetDefaultPath()\n"),&n);

 		tP.Close();

 		tT.Close();

 		//FIXME END

 		TParse parse;

 		/*TInt*/ r=ParsePathPtr0(aRequest,parse);	

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

 			return(r);

 		if (IsIllegalFullName(parse.FullName()))

 			return(KErrBadName);

 		TheDefaultPath=parse.FullName();

 		return(KErrNone);

 		}

 	else

 		{

 		TParse parse;

 		TInt r=ParsePathPtr0(aRequest,parse);	

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

 			return(r);

 		if (IsIllegalFullName(parse.FullName()))

 			return(KErrBadName);

 		TheDefaultPath=parse.FullName();

 		return(KErrNone);

 		}

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsSessionPath::DoRequestL(CFsRequest* aRequest)

 //

 // Get the session path

 //

 	{

 	aRequest->WriteL(KMsgPtr0,aRequest->Session()->Path());

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsSetSessionPath::DoRequestL(CFsRequest* aRequest)

 //

 // Set the session path

 //

 	{

 	TParse parse;

 	TInt r=ParsePathPtr0(aRequest,parse);	

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

 		return(r);

 	r=PathCheck(aRequest,parse.FullName().Mid(2),&KCapFsSysSetSessionPath,&KCapFsPriSetSessionPath, __PLATSEC_DIAGNOSTIC_STRING("Set Session Path"));

 	if (r!=KErrNone)

 		return(r);

 	if (IsIllegalFullName(parse.FullName()))

 		return(KErrBadName);

 	HBufC* pP=parse.FullName().Alloc();

 	if (pP==NULL)

 		return(KErrNoMemory);

 	delete &aRequest->Session()->Path();

 	aRequest->Session()->SetPath(pP);

 	return(KErrNone);

 	}

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

 //

 //

 //

 	{

 	return(KErrNone);

 	}

 TInt TFsParse::DoRequestL(CFsRequest* aRequest)

 //

 // Parse a file name.

 //

 	{

 	TFileName name;

 	aRequest->ReadL(KMsgPtr0,name);

 	TFileName rel;

 	if (aRequest->Message().Ptr1()!=NULL)

 		aRequest->ReadL(KMsgPtr1,rel);

 	TParse p;

 	TInt r=p.Set(name,&rel,&aRequest->Session()->Path());

 	if (r==KErrNone)

 		{

 		TPckgC<TParse> pP(p);

 		aRequest->WriteL(KMsgPtr2,pP);

 		}

 	return(r);

 	}

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

 //

 //

 //

 	{

 	return KErrNone;

 	}

 TInt TFsReserveDriveSpace::DoRequestL(CFsRequest* aRequest)

 //

 // set reserved value to add to a drives reserved area

 //	

 	{

 	// extract request info

 	CSessionFs* session=aRequest->Session(); 

 	TDrive* drive = aRequest->Drive();

 	if(session->ReservedAccess(drive->DriveNumber()))

 		return KErrInUse;

 	const TInt reserve = aRequest->Message().Int1(); //-- bytes to reserve on the drive

 	// Check if requested reserve space is within the range

 	if(reserve > KMaxSessionDriveReserved || reserve < 0) 

 		return KErrArgument;

     const TInt64 threshold = reserve + drive->ReservedSpace(); //-- free bytes on the volume we actually need 

     TInt nRes = drive->RequestFreeSpaceOnMount(threshold);

     if(nRes != KErrNone)

         return nRes;

 	const TInt current = session->Reserved(drive->DriveNumber()); 

 	const TInt diff = reserve - current;	

 	TInt drvReserved = drive->ReservedSpace();

 	if((drvReserved + diff) > KMaxTotalDriveReserved)

 		return KErrTooBig;

 	drvReserved += diff;

 	drive->SetReservedSpace(drvReserved);

 	return session->SetReserved(drive->DriveNumber(), reserve);

 	}

 TInt TFsReserveDriveSpace::Initialise(CFsRequest* aRequest)

 //

 //	Validate drive and set up the session parameters for request

 //	

 	{

 //	if (!KCapFsReserveDriveSpace.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Reserve Drive Space")))

 //		return KErrPermissionDenied;

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

 	drvNumber=aRequest->Message().Int0();

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

 	return(r);

 	}

 TInt TFsGetReserveAccess::DoRequestL(CFsRequest* aRequest)

 //

 //	Get reserved access to a drives reserved area first checking that the session has first reserved some space

 //	

 	{

 	CSessionFs* session=aRequest->Session();

 	TInt size=session->Reserved(aRequest->Drive()->DriveNumber());

 	if(size <= 0)

 		return KErrPermissionDenied;

 	else

 		session->SetReservedAccess(aRequest->Drive()->DriveNumber(),ETrue);

 	return KErrNone;

 	}

 TInt TFsGetReserveAccess::Initialise(CFsRequest* aRequest)

 //

 //

 //	

 	{

 //	if (!KCapFsGetReserveAccess.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Get Reserve Access")))

 //		return KErrPermissionDenied;

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

 	return(r);

 	}

 TInt TFsReleaseReserveAccess::DoRequestL(CFsRequest* aRequest)

 //

 //	Remove access for this session to the locked area for a given drive 

 //	

 	{

 	aRequest->Session()->SetReservedAccess(aRequest->Drive()->DriveNumber(),EFalse);

 	return KErrNone;

 	}

 TInt TFsReleaseReserveAccess::Initialise(CFsRequest* aRequest)

 //

 //

 //	

 	{

 //	if (!KCapFsReleaseReserveAccess.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Release Reserve Access")))

 //		return KErrPermissionDenied;

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

 	return(r);

 	}

 TInt TFsSetStartupConfiguration::DoRequestL(CFsRequest* aRequest)

 //

 //  Configure file server according to command and parameters.

 //	

     {

     TInt cmd = aRequest->Message().Int0();

     switch (cmd)

     {

     case ELoaderPriority:

     // Set loader thread priority

         {

         TInt r;

         TFullName loaderFullName(RProcess().FullName());

         loaderFullName.Append(_L("::LoaderThread"));

         RThread loader;

         r = loader.Open(loaderFullName);

         if (r != KErrNone)

             return r;

         loader.SetPriority((TThreadPriority)aRequest->Message().Int1());

         loader.Close();

         }

         break;

 	case ESetRugged:

 		{

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

         TInt r = ValidateDrive(drive, aRequest);

         if (r != KErrNone)

             return r;

         TInt value = aRequest->Message().Int2();

 		aRequest->Drive()->SetRugged(value);

 		}

 		break;

     default:

     	return KErrArgument;

     }

     return KErrNone;

     }

 TInt TFsSetStartupConfiguration::Initialise(CFsRequest* aRequest)

 //

 //  Check SID of message sender. Can be estart only

 //	

     {

     if (aRequest->Message().SecureId() != KEstartUidValue)

         return KErrPermissionDenied;

     return KErrNone;

     }

 const TInt KinitialChanges = EChangesLocale|EChangesMidnightCrossover|EChangesThreadDeath|EChangesPowerStatus|EChangesSystemTime|EChangesFreeMemory|EChangesOutOfMemory;

 CKernEventNotifier* CKernEventNotifier::New(TInt aPriority)

      {

      __PRINT(_L("CKernEventNotifier::New"));

      CKernEventNotifier* self = new CKernEventNotifier(aPriority);

      if (self && (self->iChangeNotifier.Create() != KErrNone))

          delete self, self = NULL;

      return self;

      }

 CKernEventNotifier::~CKernEventNotifier()

      {

      Cancel();

      iChangeNotifier.Close();

      }

 void CKernEventNotifier::Start()

      {

      SetActive();

      iChangeNotifier.Logon(iStatus);

      }

 void CKernEventNotifier::RunL()

      {

      __PRINT(_L("CKernEventNotifier::RunL"));

      iChange = iStatus.Int();

      Start();

      /* Avoid being triggered by initial events */

      if (iChange != 0 && (iChange & KinitialChanges) != KinitialChanges)   

          {

          if (iChange & EChangesLocale)

              CKernEventNotifier::LocaleChangeCallback();

          if (iChange & EChangesFreeMemory)

              CKernEventNotifier::FreeMemoryChangeCallback();

          // Add other event capture below this line

          iChange = 0;

          }

      }

 void CKernEventNotifier::DoCancel()

      {

      iChangeNotifier.LogonCancel();

      }

 extern TBool FatUtilitiesUpdateDrivesNotified;

 extern TBool FatUtilityFunctionsSet;

 TInt CKernEventNotifier::LocaleChangeCallback(TAny*)

      {

      __PRINT(_L("CKernEventNotifier::LocaleChangeCallback"));

      //-- check if the locale has just been set and the drives are not yet notified about this.

      if(FatUtilityFunctionsSet && !FatUtilitiesUpdateDrivesNotified)

         {//-- notify drives about locale shange, but only once

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

             {

             TDrive& drive=TheDrives[i];

             if(drive.DriveNumber() >=0 && drive.IsRemovable() && !drive.IsSubsted())

                 {

                 __PRINT1(_L("CKernEventNotifier::LocaleChangeCallback upd drive: %d"), drive.DriveNumber());

                 drive.SetChanged(ETrue);

                 }

             }

             FatUtilitiesUpdateDrivesNotified = ETrue;

         }

      return KErrNone;

      }

 TInt TFsQueryVolumeInfoExt::DoRequestL(CFsRequest* aRequest)

 	{

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

 	TInt rel;

     TDrive* pDrive = aRequest->Drive();

     rel = pDrive->CheckMount();

     if(rel != KErrNone)

         return rel;

 	switch (cmd)

 		{

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

         //-- file system sub type query

         case EFileSystemSubType:

 			{

 			TFSName name;

 			if (pDrive->IsMounted())

 				{

 				rel = pDrive->CurrentMount().FileSystemSubType(name);

 				//-- get the Mount's file system name if the FS subtype query is not supported or there are no subtypes.

                 if (rel==KErrNotSupported)

 					{

                     pDrive->CurrentMount().FileSystemName(name);

 					}

 				if (name.Length())

 					{

 					TPckgBuf<TFSName> pckgBuf(name);

 					aRequest->WriteL(KMsgPtr2, pckgBuf);

 					return KErrNone;

 					}

 				else

 					{

 					return rel;

 					}

 				}

 			else

 				{

 				return KErrNotReady;

 				}

 			}

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

         //-- this is RFs::VolumeIOParam() query 

         case EIOParamInfo:

 			{

 			TVolumeIOParamInfo ioInfo;

 			// 1. gets block size information via media driver

 		    const TInt drive = aRequest->Message().Int0();

 		    // validates local drive numbers

 		    if(!IsValidLocalDriveMapping(drive))

 		    	{

 		    	ioInfo.iBlockSize = KErrNotReady;

 		    	}

 		    else

 		    	{

 			    // Get media capability

 			    TLocalDriveCapsV6Buf capsBuf;

 				// is the drive local?

 				if (!IsProxyDrive(drive))

 					{

 					// if not valid local drive, use default values in localDriveCaps

 					// if valid local drive and not locked, use TBusLocalDrive::Caps() values

 					// if valid drive and locked, hard-code attributes

 					rel = GetLocalDrive(drive).Caps(capsBuf);

 					}

 				else  // this need to be made a bit nicer

 					{   

 					CExtProxyDrive* pD = GetProxyDrive(drive);

 					if(pD)

 						rel = pD->Caps(capsBuf);

 					else

 						rel = KErrNotReady;

 					}

 			    if (rel != KErrNone)

 			    	{

 			    	ioInfo.iBlockSize = rel;

 			    	}

 			    else

 			    	{

 				    TLocalDriveCapsV6& caps = capsBuf();

 					if (caps.iBlockSize)

 						{

 						ioInfo.iBlockSize = caps.iBlockSize;

 						}

 					// returns default size (512) when block is not supported by 

 					//  underlying media

 					else

 						{

 						ioInfo.iBlockSize = KDefaultVolumeBlockSize;

 						}

 			    	}

 		    	}

 			// 2. gets cluster size via mounted file system; Also get Max. file size supported by the file system

             ioInfo.iMaxSupportedFileSize = KMaxTUint64; //-- the value for "not supported case"

             if (pDrive->IsMounted())

 				{

 				rel = pDrive->CurrentMount().FileSystemClusterSize();

 				ioInfo.iClusterSize = rel; // return cluster size or an error code if error happened.

                 pDrive->CurrentMount().GetMaxSupportedFileSize(ioInfo.iMaxSupportedFileSize);

                 }

 			else

 				{

 				ioInfo.iClusterSize = KErrNotReady;

 				}

 			// 3. get rec buffer size from estart.txt file

 			{

                 _LIT8(KLitSectionNameDrive,"Drive%C");

 			    ioInfo.iRecReadBufSize = KErrNotSupported;

 			    ioInfo.iRecWriteBufSize = KErrNotSupported;

 			    TBuf8<8> sectionName;

 			    TInt32 bufSize;

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

 			    // retrieve recommended buffer size information through F32 INI section

 			    if (F32Properties::GetInt(sectionName, _L8("RecReadBufSize"), bufSize))

 				    {

 				    ioInfo.iRecReadBufSize = bufSize;

 				    }

 			    if (F32Properties::GetInt(sectionName, _L8("RecWriteBufSize"), bufSize))

 				    {

 				    ioInfo.iRecWriteBufSize = bufSize;

 				    }

 			    // packaging and returning results

 			    TPckgBuf<TVolumeIOParamInfo> pckgBuf(ioInfo);

 			    aRequest->WriteL(KMsgPtr2, pckgBuf);

 			}

 			// always return KErrNone as error codes are packaged and returned via ioInfo members

 			return KErrNone;

 			} //case EIOParamInfo:

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

             //-- check if the specified drive is synchronous or not

             case EIsDriveSync:

             {

                 const TInt drive = aRequest->Message().Int0();

                 const TBool bDrvSynch = FsThreadManager::IsDriveSync(drive, EFalse);

                 TPckgBuf<TBool> buf(bDrvSynch);

                 aRequest->WriteL(KMsgPtr2, buf);

                 return KErrNone;

             }

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

             //-- query if the drive is finalised

             case EIsDriveFinalised:

             {

                 TBool bFinalised;

                 TInt nRes = pDrive->CurrentMount().IsMountFinalised(bFinalised);

                 if(nRes != KErrNone)

                     return nRes;

                 TPckgBuf<TBool> buf(bFinalised);

                 aRequest->WriteL(KMsgPtr2, buf);

                 return KErrNone;

             }

 		default:

 			{

 			return KErrNotSupported;

 			}

 		}

 	}

 TInt TFsQueryVolumeInfoExt::Initialise(CFsRequest* aRequest)

 	{

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

 	return r;

 	}

 TInt CKernEventNotifier::FreeMemoryChangeCallback()

 	{

 	__PRINT(_L("CKernEventNotifier::FreeMemoryChangeCallback"));

 	TBool belowThreshold = (iChange & EChangesLowMemory)?(TBool)ETrue:(TBool)EFalse;

 	CCacheManager* manager = CCacheManagerFactory::CacheManager();

 	if (manager)

 		{

 		manager->FreeMemoryChanged(belowThreshold);

 		// start flushing all dirty data

 		if (belowThreshold)

 			{

 			Files->Lock();

 			TInt count=Files->Count();

 			while(count--)

 				{

 				CFileCB* file = (CFileCB*)(*Files)[count];

 				if (file->FileCache())

 					// Cannot report errors here

 					// coverity [unchecked_value]

 					(void)file->FileCache()->FlushDirty();

 				}

 			Files->Unlock();

 			}

 		}

 #ifdef	SYMBIAN_ENABLE_FAT_DIRECTORY_OPT

 	CCacheMemoryManager* cacheMemManager = CCacheMemoryManagerFactory::CacheMemoryManager();

 	if (cacheMemManager)

 		cacheMemManager->FreeMemoryChanged(belowThreshold);

 #endif //#ifdef	SYMBIAN_ENABLE_FAT_DIRECTORY_OPT

 	return KErrNone;

 	}