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