// Copyright (c) 2002-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_notif.cpp

// 

//

#include "sf_std.h"

TChangeQue FsNotify::iChangeQues[KMaxNotifyQues];

TDiskSpaceQue FsNotify::iDiskSpaceQues[KMaxDiskQues];

TDebugQue FsNotify::iDebugQue;

TDismountNotifyQue FsNotify::iDismountNotifyQue;

void CNotifyInfo::Initialise(TInfoType aType,TRequestStatus* aStatus,const RMessagePtr2& aMessage,CSessionFs* aSession)

//

//

//

	{

	iType=aType;

	iStatus=aStatus;

	iMessage=aMessage;

	iSession=aSession;

	};

CNotifyInfo::~CNotifyInfo()

//

//

//

	{

	__ASSERT_DEBUG(!iLink.iNext,Fault(ENotifyInfoDestructor));

	}

void CNotifyInfo::Complete(TInt aError)

//

//

//

	{

	__PRINT2(_L("CNotifyInfo::Complete 0x%x error=%d"),this,aError);

	if (iType != EDismount || !iMessage.IsNull())	// Dismount notifiers may be completed but remain in the list

		{											// until handled by the client or the session is closed.

		iMessage.Complete(aError);

		}

	}

void CStdChangeInfo::Initialise(TNotifyType aChangeType,TRequestStatus* aStatus,const RMessagePtr2& aMessage,CSessionFs* aSession)

//

//

//

	{

	iChangeType=aChangeType;

	CNotifyInfo::Initialise(EStdChange,aStatus,aMessage,aSession);

	}

TUint CStdChangeInfo::RequestNotifyType(CFsRequest* aRequest)

//

// return notification type for the request

//

	{

	TUint notifyType=aRequest->Operation()->NotifyType();

	if(aRequest->Operation()->Function()==EFsRename)

		{

		__ASSERT_DEBUG(notifyType==(ENotifyDir|ENotifyFile|ENotifyEntry),Fault(EStdChangeRequestType));

		if(aRequest->Src().NamePresent())

			notifyType=ENotifyFile|ENotifyEntry;

		else

			notifyType=ENotifyDir|ENotifyEntry;

		}

	return(notifyType);						

	}

TBool CStdChangeInfo::IsMatching(CFsRequest* aRequest)

//

// return ETrue if operation type of request matches that of change notification

//

	{

	if((iChangeType&ENotifyAll) || (iChangeType&aRequest->Operation()->NotifyType()))

		return(ETrue);

	else

		return(EFalse);

	}

void CExtChangeInfo::Initialise(TNotifyType aChangeType,TRequestStatus* aStatus,const RMessagePtr2& aMessage,CSessionFs* aSession,const TDesC& aName)

//

//

//

	{

	__ASSERT_DEBUG(aName.Length()<=KMaxFileName-2,Fault(EExtChangeNameLength));

	iName=aName;

	iChangeType=aChangeType;

	CNotifyInfo::Initialise(EExtChange,aStatus,aMessage,aSession);

	}

TBool CExtChangeInfo::IsMatching(CFsRequest* aRequest)

//

// return ETrue if operation notify type of request matches that of change notification

// and paths match

//

	{

	TInt function=aRequest->Operation()->Function();

	//	if a rename occurred inform any requests if their path has been changed regardless of the notification type

	if(function==EFsRename)				

		{		

		TBuf<KMaxFileName> renamePath=aRequest->Src().FullName().Mid(2);		

		renamePath+=_L("*");

		if (iName.MatchF(renamePath)!=KErrNotFound)	

			return(ETrue);

		}

	//Special case where the dir the notifier is setup on has just been created

	if(function==EFsMkDir)	

		{		

		TInt notDrive;

		RFs::CharToDrive(aRequest->Src().Drive()[0],notDrive);	//can not fail as the drive letter has been parsed already

		if(aRequest->Src().Path().MatchF(iName) == 0 && aRequest->DriveNumber() == notDrive)

			return ETrue;

		}

	//Special case where  the File the notifier is setup on has just been created by temp as the name is not known unti it has been created

	if(function==EFsRename||function==EFsFileOpen||function==EFsFileCreate||function==EFsFileReplace)

		{

		TInt notDrive;

		RFs::CharToDrive(aRequest->Src().Drive()[0],notDrive);	//can not fail as the drive letter has been parsed already

		if(aRequest->Src().FullName().Mid(2).MatchF(iName) == 0 && aRequest->DriveNumber() == notDrive)

			return ETrue;

		}

	//For the case of a file created using EFsFileTemp we can probably ignore it for special cases as it 

	//is created with a random name. Not specifically going to be being looked for

	if((iChangeType&ENotifyAll) || (iChangeType&RequestNotifyType(aRequest)))

		{

		switch (function)

			{	

		//	Notify interested requests if a SetDriveName(), SetVolume() or RawDiskWrite() operation

		//	occcurred.  By their nature, these operations have no distinct path.  All outstanding

		//	requests monitoring the relevant TNotifyType are potentially interested in such operations	

			case EFsFileWrite:

			case EFsFileWriteDirty:

			case EFsFileSet:

			case EFsFileSetAtt:

			case EFsFileSetModified:

			case EFsFileSetSize:

			{

			TBuf<KMaxFileName> root=iName;

			root+=_L("*");	

			// NB share may be NULL if file server has initiated a flush of the file cache

			CFileShare* share;

			CFileCB* fileCache;

			GetFileFromScratch(aRequest, share, fileCache);

			if (share && share->File().FileName().MatchF(root) != KErrNotFound)

				return(ETrue);

			}

			break;

			case EFsSetDriveName:

			case EFsSetVolume:

			case EFsRawDiskWrite:

			case EFsLockDrive:

			case EFsUnlockDrive:

			case EFsReserveDriveSpace:

				{

				return(ETrue);				

				}

			default:

				{	

				TBuf<KMaxFileName> root = iName;

				root+=_L("*");	

				if(aRequest->Src().FullName().Mid(2).MatchF(root)!=KErrNotFound)

					return(ETrue);	

				else if(function==EFsRename||function==EFsReplace||function==EFsFileRename)

					{

					// - rename/replace causes the file/path to disappear

					if(aRequest->Dest().FullName().Mid(2).MatchF(root)!=KErrNotFound)

						{

						return(ETrue);

						}

					// - rename/replace causes the file/path to arrive

					root=aRequest->Dest().FullName().Mid(2);

					root+=_L("*");

					if (iName.MatchF(root)!=KErrNotFound)

						{

						return(ETrue);

						}

					}

				}			

			}

		}

	return(EFalse);

	}

void CDiskSpaceInfo::Initialise(TRequestStatus* aStatus,const RMessagePtr2& aMessage,CSessionFs* aSession,TInt64 aThreshold)

//

//

//

	{

	__ASSERT_DEBUG(aThreshold>0,Fault(EDiskSpaceThreshold));

	iThreshold=aThreshold;

	CNotifyInfo::Initialise(EDiskSpace,aStatus,aMessage,aSession);

	}

TBool CDiskSpaceInfo::IsMatching(TInt64& aBefore,TInt64& aAfter)

//

// return ETrue if the threshold has been crossed

//

	{

	if((aBefore>=iThreshold&&aAfter<iThreshold)||(aBefore<=iThreshold&&aAfter>iThreshold))

		return(ETrue);

	return(EFalse);

	}

void CDebugChangeInfo::Initialise(TUint aDebugType,TRequestStatus* aStatus,const RMessagePtr2& aMessage,CSessionFs* aSession)

//

//

//

	{

	__ASSERT_DEBUG((aDebugType&KDebugNotifyMask)&&!(aDebugType&~KDebugNotifyMask),Fault(EDebugChangeType));

	iDebugType=aDebugType;

	CNotifyInfo::Initialise(EDebugChange,aStatus,aMessage,aSession);

	}

TBool CDebugChangeInfo::IsMatching(TUint aFunction)

//

// return ETrue if debug notification type matches aFunction

//

	{

	if(iDebugType&aFunction)

		return(ETrue);

	return(EFalse);

	}

CDismountNotifyInfo::~CDismountNotifyInfo()

	{

	switch(iMode)

		{

		case EFsDismountNotifyClients:

			break;

		case EFsDismountRegisterClient:

			__ASSERT_ALWAYS(TheDrives[iDriveNumber].DismountUnlock() >= 0, Fault(ENotifyDismountCancel));

			break;

		default:

			break;

		}

	}

void CDismountNotifyInfo::Initialise(TNotifyDismountMode aMode, TInt aDriveNumber, TRequestStatus* aStatus,const RMessagePtr2& aMessage,CSessionFs* aSession)

	{

	iMode = aMode;

	iDriveNumber=aDriveNumber;

	CNotifyInfo::Initialise(EDismount,aStatus,aMessage,aSession);

	if (iMode == EFsDismountRegisterClient)

		TheDrives[iDriveNumber].DismountLock();

	}

TBool CDismountNotifyInfo::IsMatching(TNotifyDismountMode aMode, TInt aDriveNumber, CSessionFs* aSession)

	{

	if((iDriveNumber == aDriveNumber) && (iMode == aMode) && (aSession == NULL || aSession == Session()))

		return(ETrue);

	return(EFalse);

	}

TBaseQue::TBaseQue()

//

//

//

	{

	iHeader.SetOffset(_FOFF(CNotifyInfo,iLink));

	TInt r=iQLock.CreateLocal();

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

	}

TBaseQue::~TBaseQue()

//

//

//

	{

	iQLock.Close();

	}

void TBaseQue::DoAddNotify(CNotifyInfo* aInfo)

//

// Add notification

// Que should be locked by calling function

//

	{

	iHeader.AddLast(*aInfo);

	}

TBool TBaseQue::DoCancelSession(CSessionFs* aSession,TInt aCompletionCode, TRequestStatus* aStatus)

//

// Cancel notification(s) setup by aSession matching aStatus if set

// Que should be locked by calling function

//

	{

	TDblQueIter<CNotifyInfo> q(iHeader);

	CNotifyInfo* info;

	TBool isFound=EFalse;

	while((info=q++)!=NULL)

		{

		if(info->Session()==aSession && (!aStatus || aStatus==info->Status()))

			{

			isFound=ETrue;

			info->Complete(aCompletionCode);

			info->iLink.Deque();

			delete(info);

			if(aStatus)

				break;

			}

		}

	return(isFound);

	}

void TBaseQue::DoCancelAll(TInt aCompletionCode)

//

// Cancel all notifications

// Que should be locked by calling function

//

	{

	TDblQueIter<CNotifyInfo> q(iHeader);

	CNotifyInfo* info;

	while((info=q++)!=NULL)

		{

		info->Complete(aCompletionCode);

		info->iLink.Deque();

		delete(info);

		}

	__ASSERT_DEBUG(iHeader.IsEmpty(),Fault(EBaseQueCancel));

	}

TBool TBaseQue::IsEmpty()

//

// Que should be locked by calling function

//

	{

	return iHeader.IsEmpty();

	}

TBool TChangeQue::IsEmpty()

//

//

//

	{

	iQLock.Wait();

	TBool empty = TBaseQue::IsEmpty();

	iQLock.Signal();

	return(empty);

	}

TInt TChangeQue::AddNotify(CNotifyInfo* aInfo)

//

//

//

	{

	iQLock.Wait();

	TBaseQue::DoAddNotify(aInfo);

	iQLock.Signal();

	return(KErrNone);

	}

TBool TChangeQue::CancelSession(CSessionFs* aSession,TInt aCompletionCode,TRequestStatus* aStatus)

//

//

//

	{

	iQLock.Wait();

	TBool isFound=TBaseQue::DoCancelSession(aSession,aCompletionCode,aStatus);

	iQLock.Signal();

	return(isFound);

	}

void TChangeQue::CancelAll(TInt aCompletionCode)

//

//

//

	{

	iQLock.Wait();

	TBaseQue::DoCancelAll(aCompletionCode);

	iQLock.Signal();

	}

void TChangeQue::CheckChange(CFsRequest* aRequest)

//

// complete any notification in que that matches aRequest

//

	{

	iQLock.Wait();

	TDblQueIter<CNotifyInfo> q(iHeader);

	CNotifyInfo* info;

	while((info=q++)!=NULL)

		{

		__ASSERT_DEBUG(info->Type()==CNotifyInfo::EStdChange||info->Type()==CNotifyInfo::EExtChange,Fault(EChangeQueType));

		TBool isMatching;

		if(info->Type()==CNotifyInfo::EStdChange)

			isMatching=((CStdChangeInfo*)info)->IsMatching(aRequest);

		else

			isMatching=((CExtChangeInfo*)info)->IsMatching(aRequest);

		if(isMatching)

			{

			__PRINT1(_L("TChangeQue::CheckChange()-Matching info=0x%x"),info);

			info->Complete(KErrNone);

			info->iLink.Deque();

			delete(info);

			}

		}

	iQLock.Signal();

	}

TBool TDiskSpaceQue::IsEmpty()

//

//

//

	{

	iQLock.Wait();

	TBool empty = TBaseQue::IsEmpty();

	iQLock.Signal();

	return(empty);

	}

TInt TDiskSpaceQue::AddNotify(CNotifyInfo* aInfo)

//

//

//

	{

	iQLock.Wait();

	TInt r=KErrNone;

	if(iHeader.IsEmpty())

		{

		r=GetFreeDiskSpace(iFreeDiskSpace);

		iReservedDiskSpace = TheDrives[iDriveNumber].ReservedSpace();

		}

	if(r==KErrNone)

		TBaseQue::DoAddNotify(aInfo);

	iQLock.Signal();

	return(r);

	}

TInt TDiskSpaceQue::CancelSession(CSessionFs* aSession,TInt aCompletionCode,TRequestStatus* aStatus)

//

//

//

	{

	iQLock.Wait();

	TBaseQue::DoCancelSession(aSession,aCompletionCode,aStatus);

	iQLock.Signal();

	return(KErrNone);

	}

void TDiskSpaceQue::CancelAll(TInt aCompletionCode)

//

//

//

	{

	iQLock.Wait();

	TBaseQue::DoCancelAll(aCompletionCode);

	iQLock.Signal();

	}

void TDiskSpaceQue::CheckDiskSpace()

//

// Complete any disk space notification whose threshold has been crossed

//

	{

	iQLock.Wait();

	if(iHeader.IsEmpty())

		{

		iQLock.Signal();

		return;

		}

	TInt64 freeSpace;

	TInt r=GetFreeDiskSpace(freeSpace);

	TInt64 reservedSpace(TheDrives[iDriveNumber].ReservedSpace());

	if(r==KErrNone)

		{

		if((freeSpace==iFreeDiskSpace) && (reservedSpace==iReservedDiskSpace))

			{

			iQLock.Signal();

			return;

			}

		TDblQueIter<CNotifyInfo> q(iHeader);

		CNotifyInfo* info;

		while((info=q++)!=NULL)

			{

			__ASSERT_DEBUG(info->Type()==CNotifyInfo::EDiskSpace,Fault(EDiskSpaceQueType1));

			TInt64 newSessionFreeSpace(freeSpace);

			TInt64 oldSessionFreeSpace(iFreeDiskSpace);

			if(!info->Session()->ReservedAccess(iDriveNumber))

				{

				newSessionFreeSpace -= reservedSpace;

				oldSessionFreeSpace -= iReservedDiskSpace;

				}

			if(((CDiskSpaceInfo*)info)->IsMatching(oldSessionFreeSpace,newSessionFreeSpace))

				{

				__PRINT1(_L("TDiskSpaceQue::CheckDiskSpace()-Matching info=0x%x"),info);

				info->Complete(KErrNone);

				info->iLink.Deque();

				delete(info);

				}

			}

		iFreeDiskSpace=freeSpace;

		iReservedDiskSpace=reservedSpace;

		}

	else