// Copyright (c) 2008-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_notifier.cpp

// 

//

#include "sf_notifier.h"

#include "sf_file_cache.h"

CFsObjectCon* FsNotificationManager::iNotifyRequests = NULL;

RFastLock FsNotificationManager::iChainLock;

TInt FsNotificationManager::iFilterRegister[];

CFsPool<CFsNotificationBlock>* FsNotificationManager::iPool;

CFsNotificationPathFilter* CFsNotificationPathFilter::NewL(const TDesC& aPath, const TDesC& aFilename)

	{

	CFsNotificationPathFilter* self = new (ELeave) CFsNotificationPathFilter();

	CleanupStack::PushL(self);

	self->ConstructL(aPath,aFilename);

	CleanupStack::Pop(self);

	return self;

	}

void CFsNotificationPathFilter::ConstructL(const TDesC& aPath, const TDesC& aFilename)

	{

	//Allocate the path and filename

	iPath = aPath.AllocL();

	iFilename = aFilename.AllocL();	

	}

CFsNotificationPathFilter::~CFsNotificationPathFilter()

	{

	if(iFilename)

		delete iFilename;

	if(iPath)

		delete iPath;

	}

CFsNotificationPathFilter::CFsNotificationPathFilter()

: iPath(NULL), iFilename(NULL)

	{

	}

CFsNotifyRequest* CFsNotifyRequest::NewL()

	{

	CFsNotifyRequest* self = new(ELeave) CFsNotifyRequest();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CFsNotifyRequest::ConstructL()

	{

	User::LeaveIfError(iClientSyncLock.CreateLocal());

	User::LeaveIfError(iTailSemaphore.CreateLocal()); 

	}

CFsNotifyRequest::CFsNotifyRequest()

	{

	SetActive(EInactive);

	}

CFsNotifyRequest::~CFsNotifyRequest()

	{

	__PRINT(_L("CFsNotifyRequest::~CFsNotifyRequest()"));

	RemoveFilters();

	if(ClientMsgHandle()!=0)

		iClientMsg.Complete(KErrCancel);

	if(iBufferMsg.Handle()!=0)

		iBufferMsg.Complete(KErrCancel);

	iClientSyncLock.Close();

	iTailSemaphore.Close();

	}

/*

 * Returns the Array of TypeFilters.

 * Each TFsNotificationTypeFilter matches to a particular TFsNotification::TFsNotificationType

 * and has a CFsNotificationFilter which stores the iPath and iName associated with this filter type.

 * 

 * (These are speerated so that we can have multiple type filters for every name filter)

 */

TFsNotificationTypeArray* CFsNotifyRequest::FilterTypeList(TInt aDrive,TInt aIndex)

	{

	__ASSERT_DEBUG(aIndex < KNumRegisterableFilters,Fault(ENotificationFault));

	TFsNotificationTypeDriveArray* filters = iDrivesTypesFiltersMap.Find(aDrive);

	if(filters)

		return &((*filters)[aIndex]);

	else

		return NULL;

	}

//Sets filter's notification request status

void CFsNotifyRequest::SetActive(TNotifyRequestStatus aValue)

	{

	iNotifyRequestStatus = aValue;

	}

CFsNotifyRequest::TNotifyRequestStatus CFsNotifyRequest::ActiveStatus()

	{

	return (TNotifyRequestStatus)iNotifyRequestStatus;

	}

//Completes and frees notification request

//In case of KErrNone must be called with iChainLock already held

void CFsNotifyRequest::CompleteClientRequest(TInt aReason,TBool aIsCancel)

	{

	__PRINT(_L("CFsNotifyRequest::CompleteClientRequest()"));

	iClientSyncLock.Wait();

	if(aReason==KErrNone) 

		{

		__PRINT(_L("CFsNotifyRequest::CompleteClientRequest() - Complete KErrNone"));

		//Synchronising the current iServerTail to the client.

		iClientHead = iClientTail; //Client has read all previous entries

		iClientTail = iServerTail; //Client's new tail is everything the server has been writing since this function was last called

		TInt clientTail = iClientTail;

		TPckg<TInt> tailDes(clientTail);

		iClientMsg.Write(KMsgPtr0,tailDes);

		}

	else if(aIsCancel)

		{

		__PRINT(_L("CFsNotifyRequest::CompleteClientRequest() - Complete isCancel"));

		iServerTail = 0;

		iClientTail = 0;

		iClientHead = 0;

		TPckgBuf<TInt> tailDes(iClientTail);

		//Perhaps client has crashed so no point checking return:

		iClientMsg.Write(KMsgPtr0,tailDes); 

		}

	__PRINT(_L("CFsNotifyRequest::CompleteClientRequest() - Complete Request"));

	iClientMsg.Complete(aReason);

	iClientSyncLock.Signal();

	}

TInt CFsNotifyRequest::SynchroniseBuffer(CFsNotificationBlock& aBlock,TInt aServerTail, TInt aNotificationSize)

	{

	TPtrC8 blockDes((TText8*)aBlock.Data(),aNotificationSize);

	return iBufferMsg.Write(KMsgPtr0,blockDes,aServerTail);

	}

//Removes all filters.

//Deletes iPath, iFilename

TInt CFsNotifyRequest::RemoveFilters()

	{

	__PRINT(_L("CFsNotifyRequest::RemoveFilters()"));

	//For every drive with filters set...

	RHashMap<TInt,TFsNotificationTypeDriveArray>::TIter iterator(iDrivesTypesFiltersMap);

	TFsNotificationTypeDriveArray* currentDriveFilters = (TFsNotificationTypeDriveArray*)iterator.NextValue();

	while(currentDriveFilters)

		{

		//For every filter array (1 for each type of TFsNotificationType)

		for(TInt filterType = 0; filterType < KNumRegisterableFilters; filterType++)

			{

			TFsNotificationTypeArray& filterList = (*currentDriveFilters)[filterType];

			TInt filterTypeCount = filterList.Count();

			if(filterTypeCount)

				{

				//Remove this type from the filter register

				TFsNotification::TFsNotificationType type = FsNotificationHelper::NotificationType(filterType);

				FsNotificationManager::SetFilterRegister(type,EFalse,filterTypeCount);

				}

			filterList.Reset();

			filterList.Close();

			}

		currentDriveFilters->Reset();

		currentDriveFilters->Close();

		iterator.RemoveCurrent();

		currentDriveFilters = (TFsNotificationTypeDriveArray*)iterator.NextValue();

		}

	iDrivesTypesFiltersMap.Close();

	iPathFilterList.ResetAndDestroy();

	iPathFilterList.Close();

	return KErrNone;

	}

TInt CFsNotifyRequest::AddFilterL(CFsNotificationPathFilter* aFilter, TUint aMask)

	{

	__PRINT(_L("CFsNotifyRequest::AddFilterL"));

	iPathFilterList.AppendL(aFilter);

	//Get the drive number to so know which drive array to add the filter(s) to.

	TInt driveNum = FsNotificationHelper::DriveNumber(aFilter->iPath->Des()); 

	TInt notifyType = 1; 

	TInt r = KErrNone;

	//Create/Add a TypeFilter for each type in aMask

	while((notifyType & KNotificationValidFiltersMask) && (aMask & KNotificationValidFiltersMask))

		{

		//If this notifyType is present in aMask

		if(aMask & notifyType)

			{

			TFsNotificationTypeFilter typeFilter;

			typeFilter.iNotificationType = (TFsNotification::TFsNotificationType) notifyType;

			typeFilter.iPathFilter = aFilter;

			TInt index = FsNotificationHelper::TypeToIndex(typeFilter.iNotificationType);

			//If the per-drive-filterLists have not

			//been set up yet then do so now.

			TFsNotificationTypeDriveArray* driveArray = iDrivesTypesFiltersMap.Find(driveNum);

			if(!driveArray)

				{

				TFsNotificationTypeDriveArray dArray;

				r = iDrivesTypesFiltersMap.Insert(driveNum,dArray);

				User::LeaveIfError(r);					

				driveArray = iDrivesTypesFiltersMap.Find(driveNum);

				//Create filter arrays for every type

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

					{

					TFsNotificationTypeArray filterArray;

					driveArray->Append(filterArray);

					}

				}

			TFsNotificationTypeArray& filterArray= (*driveArray)[index];

			filterArray.Append(typeFilter);

			//Remove this type from our mask

			//and continue

			aMask ^= notifyType;

			}

		notifyType <<= 1;

		}

	return r;

	}

TInt CFsNotifyRequest::SetClientMessage(const RMessage2& aClientMsg)

	{

	__PRINT(_L("CFsNotifyRequest::SetClientMessage"));

	iClientMsg = aClientMsg;

	return KErrNone;

	}

TInt CFsNotifyRequest::ClientMsgHandle()

	{

	return iClientMsg.Handle();

	}

void CFsNotifyRequest::CloseNotification()

	{

	__PRINT(_L("CFsNotifyRequest::CloseNotification()"));

	iBufferMsg.Complete(KErrNone);

	if(ClientMsgHandle()!=0)

		CompleteClientRequest(KErrCancel,EFalse);

	}

//New notification request from client

void FsNotificationManager::AddNotificationRequestL(CFsNotifyRequest* aNotificationRequest)

	{

	__PRINT(_L("FsNotificationManager::AddNotificationRequestL"));

	Lock();

	iNotifyRequests->AddL(aNotificationRequest,ETrue);

	Unlock();

	}

//Notification request cancelled

//Must be called with iChainLock held

void FsNotificationManager::RemoveNotificationRequest(CFsNotifyRequest* aNotificationRequest)

	{

	__PRINT(_L("FsNotificationManager::RemoveNotificationRequest"));

	iNotifyRequests->Remove(aNotificationRequest,ETrue);

	}

void FsNotificationManager::RemoveNotificationRequest(CSessionFs* aSession)

	{

	__PRINT(_L("FsNotificationManager::RemoveNotificationRequest(CSessionFs*)"));

	TInt count = Count();

	if(count)

		{

		Lock();

		count = Count(); //check again just incase it's changed before we got the lock

		if(count)

			{

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

				{

				//Remove all notification requests associated with this session.

				CFsNotifyRequest* notify = (CFsNotifyRequest*)(*iNotifyRequests)[i];

				if(notify->iSession == aSession)

					{

					RemoveNotificationRequest(notify);

					delete notify;

					}

				}

			if(!Count())

				{

				__PRINT(_L("FsNotificationManager::RemoveNotificationRequest(CSessionFs*) - Closing Manager"));

				Close();

				}

			}

		Unlock();

		}

	}

TBool FsNotificationManager::IsInitialised()

	{

	__PRINT(_L("FsNotificationManager::IsInitialised()"));

	return (TBool)iNotifyRequests;

	}

void FsNotificationManager::OpenL()

	{

	__PRINT(_L("FsNotificationManager::InitialiseL()"));

	if(!iNotifyRequests)

		{

		if(iChainLock.Handle() == 0)

			{

			User::LeaveIfError(iChainLock.CreateLocal());	

			}

		iNotifyRequests = TheContainer->CreateL();

		iPool = CFsPool<CFsNotificationBlock>::New(KNotificationPoolSize);

		User::LeaveIfNull(iPool);

		}

	}

void FsNotificationManager::SetFilterRegister(TUint aFilter, TBool aAdd, TInt aCount)

	{

	__PRINT2(_L("FsNotificationManager::SetFilterRegister(aFilter=%u,aAdd=%d)"),aFilter,aAdd);

	TInt index = FsNotificationHelper::TypeToIndex((TFsNotification::TFsNotificationType)aFilter);

	TInt& fr = FsNotificationManager::FilterRegister(index);

	__ASSERT_DEBUG((aAdd) ? fr >= 0 : fr > 0,Fault(ENotificationFault));

	fr+= aAdd ? aCount : -aCount; 

	}

void FsNotificationManager::SetFilterRegisterMask(TUint aMask,TBool aAdd)

	{

	__PRINT(_L("FsNotificationManager::RegisterFilterMask()"));

	TInt notifyType = 1; 

	while(notifyType & KNotificationValidFiltersMask && aMask & KNotificationValidFiltersMask)

		{

		if(aMask & notifyType)

			{

			SetFilterRegister(notifyType,aAdd);

			aMask ^= notifyType;

			}

		notifyType <<= 1;

		}

	}

TInt& FsNotificationManager::FilterRegister(TInt aIndex)

	{

	__PRINT(_L("FsNotificationManager::FilterRegister()"));

	__ASSERT_DEBUG(aIndex < KNumRegisterableFilters,Fault(ENotificationFault));

	return iFilterRegister[aIndex];

	}

//Must be called with the iChainLock

void FsNotificationManager::Close()

	{

	__PRINT(_L("FsNotificationManager::Stop()"));

	CFsObjectCon*& request = iNotifyRequests;

	if(request)

		{

		TheContainer->Delete(request);

		delete iPool;

		iPool = NULL;

		}

	request = NULL;

	}

TInt FsNotificationManager::Count()

	{

	__PRINT(_L("FsNotificationManager::Count()"));

	if(IsInitialised())

		return iNotifyRequests->Count();

	return 0;

	}

void FsNotificationManager::Lock()

	{

	__PRINT(_L("--->FsNotificationManager::Lock()"));

	iChainLock.Wait();

	}

void FsNotificationManager::Unlock()

	{

	__PRINT(_L("<---FsNotificationManager::Unlock()"));

	iChainLock.Signal();

	}

//Get the notification type based on the TFsMessage function

void FsNotificationHelper::NotificationType(TInt aFunction,TFsNotification::TFsNotificationType& aNotificationType)

	{

	__PRINT(_L("FsNotificationHelper::NotificationType"));

	switch(aFunction)

		{

		case EFsFileWrite:

		case EFsFileWriteDirty:

		case EFsFileSetSize:

			{

			aNotificationType = TFsNotification::EFileChange;

			break;

			}

		case EFsRename:

		case EFsFileRename:

		case EFsReplace:

			{

			aNotificationType = TFsNotification::ERename;

			break;

			}

		case EFsMkDir:

		case EFsFileCreate:

		case EFsFileReplace:

			{

			aNotificationType = TFsNotification::ECreate;

			break;

			}

		case EFsFileSetAtt:

		case EFsFileSet:

		case EFsSetEntry:

			{

			aNotificationType = TFsNotification::EAttribute;

			break;

			}

		case EFsDelete:

		case EFsRmDir:

			{

			aNotificationType = TFsNotification::EDelete;

			break;

			}

		case EFsSetVolume:

			{

			aNotificationType = TFsNotification::EVolumeName;

			break;

			}

		case EFsSetDriveName:

			{

			aNotificationType = TFsNotification::EDriveName;

			break;

			}

		case EFsDismountFileSystem:

		case EFsMountFileSystem:

		case EFsFormatNext:

		case EFsRawDiskWrite:

		case EFsMountFileSystemScan:

			{

			aNotificationType = TFsNotification::EMediaChange;

			break;

			}

		default:

			{

			aNotificationType = (TFsNotification::TFsNotificationType)0;

			break;

			}

		}

	}

//=====CFsNotificationBlock============================

// Uses CFsPool

CFsNotificationBlock* CFsNotificationBlock::New()

	{

	return new CFsNotificationBlock();

	}

CFsNotificationBlock::CFsNotificationBlock()

	{

	}

CFsNotificationBlock::~CFsNotificationBlock()

	{

	//Nothing to do here

	}

TAny* CFsNotificationBlock::Data()

	{

	return (TAny*)&iData;

	}

//=====FsNotificationManager===========================

//Get the path of the file, folder or drive name based on the TFsMessage function

void FsNotificationHelper::PathName(CFsClientMessageRequest& aRequest, TDes& aPath)

	{

	__PRINT(_L("FsNotificationHelper::PathName"));

	//Get the notification type

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

	//Get the filename(s)

	switch(function)

		{

		case EFsFileWrite:			//EParseSrc | EFileShare

		case EFsFileSetSize:		//EParseSrc | EFileShare

		case EFsFileSetAtt:			//EParseDst | EParseSrc, - should not use these; has share.

		case EFsFileSet:

		case EFsFileWriteDirty:		//EFileShare

			{

			CFileShare* share = NULL;

			CFileCB* file = NULL;

			GetFileFromScratch(&aRequest,share,file);	

			aPath.Append(file->DriveNumber() + 'A');

			aPath.Append(':');

			aPath.Append(file->FileName().Des());

			break;

			}

		case EFsFileCreate:			//EParseSrc

		case EFsDelete:				//EParseSrc

		case EFsSetEntry:			//EParseSrc,

		case EFsFileRename:			//EParseDst | EParseSrc,

		case EFsRename:				//EParseDst | EParseSrc,

		case EFsReplace:			//EParseDst | EParseSrc,

		case EFsFileReplace:		//EParseSrc

			{

			aPath.Copy(aRequest.Src().FullName());

			break;

			}

        case EFsRmDir:              //EParseSrc

        case EFsMkDir:              //EParseSrc

            {

            aPath.Copy(aRequest.Src().DriveAndPath());

            break;

            }

		case EFsFormatNext:			//EParseSrc

		case EFsDismountFileSystem: //0

		case EFsMountFileSystem:	//0

		case EFsSetVolume:			//0

		case EFsSetDriveName:		//ESync

		case EFsRawDiskWrite:		//EParseSrc

		case EFsMountFileSystemScan:

			{

			_LIT(KFormatDrive,"?:");

			TBuf<2> drive;

			drive.Append(KFormatDrive);

			drive[0] = TText(aRequest.Drive()->DriveNumber() + 'A');

			aPath.Copy(drive);

			break;

			}

		default:

			ASSERT(0);

			break;

		}

	}

//Get the new path of the file, folder or drive name based on the TFsMessage function

void FsNotificationHelper::NewPathName(CFsClientMessageRequest& aRequest, TPtrC& aNewPath)

	{

	__PRINT(_L("FsNotificationHelper::NewPathName"));

	//Get the notification type

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

	//Get the filename(s)

	switch(function)

		{

		case EFsFileRename:			//EParseDst | EParseSrc,

		case EFsRename:				//EParseDst | EParseSrc,

		case EFsReplace:			//EParseDst | EParseSrc,

			{

			aNewPath.Set(aRequest.Dest().FullName());

			break;

			}

		case EFsSetDriveName:		//ESync

			{

			TFileName name;

			aRequest.ReadL(KMsgPtr1, name);

			aNewPath.Set(name);

			break;

			}

		case EFsSetVolume:			//0

			{

			TFileName name;

			aRequest.ReadL(KMsgPtr0, name);

			aNewPath.Set(name);

			break;

			}

		default:

			{

			ASSERT(0);

			break;

			}

		}

	}

//Get the size of the notification based on its type

TInt FsNotificationHelper::NotificationSize(CFsClientMessageRequest& aRequest, TFsNotification::TFsNotificationType aNotificationType, const TDesC& aName)

	{

	__PRINT(_L("FsNotificationHelper::NotificationSize"));

	/*

	 * If there are no new names, the order of the data in the buffer is:

	 * Word1   : NotificationSize (2 bytes) , PathSize (2 bytes)

	 * Word2   : NotificationType (Lower 2 bytes)

	 * Word(s) : Path (TText8) , [Any sub-class members]

	 * 

	 * Else for notification types ERename, EVolumeName and EDriveName the order is:

	 * Word1   : NotificationSize (2 bytes) , PathSize (2 bytes)

	 * Word2   : NewNameSize (2 bytes) , NotificationType (2 bytes)

	 * Word(s) : Path (TText8) , NewName (TText8)

	 * 

	 * EOverflow size: KNotificationHeaderSize

	 */	

	TInt size = KNotificationHeaderSize + Align4(aName.Size());

	switch(aNotificationType)

		{

		//NewName

 		case TFsNotification::ERename:

		case TFsNotification::EVolumeName:

		case TFsNotification::EDriveName:

			{

			TPtrC dest;

			NewPathName(aRequest,dest);

			size += Align4(dest.Size()); 

			break;

			}

		case TFsNotification::EFileChange:

			{

			size += sizeof(TInt64);

			break;

			}

		case TFsNotification::EAttribute:

			{

			size += sizeof(TUint64);

			break;

			}

		case TFsNotification::ECreate: 

		case TFsNotification::EDelete:

		case TFsNotification::EMediaChange:

			{

			break;

			}

		default:

			{

			ASSERT(0);

			break;

			}

		}

	return (TUint16) size;

	}

TFsNotification::TFsNotificationType FsNotificationHelper::NotificationType(TInt& aIndex)

	{

	__PRINT(_L("FsNotificationHelper::NotificationType(TInt)"));

	__ASSERT_DEBUG(aIndex < KNumRegisterableFilters, Fault(ENotificationFault));

	switch(aIndex) //No break statements here on purpose

		{

		case 7 : return TFsNotification::EMediaChange;

		case 6 : return TFsNotification::EDriveName;

		case 5 : return TFsNotification::EVolumeName;

		case 4 : return TFsNotification::EDelete;

		case 3 : return TFsNotification::EAttribute;

		case 2 : return TFsNotification::ECreate;

		case 1 : return TFsNotification::ERename;

		case 0 : return TFsNotification::EFileChange;

		default: ASSERT(0); return (TFsNotification::TFsNotificationType) 0;

		}

	}

//Get the array index of the notification based on its type

TInt FsNotificationHelper::TypeToIndex(TFsNotification::TFsNotificationType aType)

	{

	__PRINT(_L("FsNotificationHelper::ArrayIndex"));

	TInt index = 0; 

	switch(aType) //No break statements here on purpose

		{

		case TFsNotification::EMediaChange: index++;

		case TFsNotification::EDriveName:	index++;

		case TFsNotification::EVolumeName:	index++;

		case TFsNotification::EDelete:	 	index++;

		case TFsNotification::EAttribute:	index++;

		case TFsNotification::ECreate:	 	index++;

		case TFsNotification::ERename:	 	index++;

		case TFsNotification::EFileChange:	// skip;

		default: break;

		}

	__ASSERT_DEBUG(index < KNumRegisterableFilters, Fault(ENotificationFault));

	return index;

	}

TInt FsNotificationHelper::DriveNumber(const TPtrC& aPath)

	{

	if(aPath.Length() >= 2 && ((TChar)aPath[1])==(TChar)':')

		{

		TChar driveChar = ((TChar)aPath[0]);

		driveChar.UpperCase();

		TInt driveNum = driveChar-(TChar)'A'; 

		return driveNum;

		}

	else

		{

		return KErrNotFound;

		}

	}

//Get the attributes set and cleared

void FsNotificationHelper::Attributes(CFsClientMessageRequest& aRequest, TUint& aSet, TUint& aClear)

	{

	__PRINT(_L("FsNotificationHelper::Attributes"));

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

	const RMessage2& msg = aRequest.Message();

	switch(function)

		{

		case EFsFileSet:

			{

			aSet = msg.Int1();

			aClear = msg.Int2();

			break;

			}

		case EFsFileSetAtt:

			{

			aSet = msg.Int0();

			aClear = msg.Int1();

			break;

			}

		case EFsSetEntry:

			{

			aSet = msg.Int2();

			aClear = msg.Int3();

			break;

			}

		default:

			{

			ASSERT(0);

			break;

			}

		}

	}

TBool CFsNotifyRequest::ValidateNotification(TInt aNotificationSize, TInt& aServerTail)

	{

	__PRINT(_L("CFsNotifyRequest::ValidateNotification"));

	//RDebug::Print(_L("CFsNotifyRequest::ValidateNotification - iServerTail=%d, aServerTail=%d, iClientTail=%d,iClientHead=%d, aNotificationSize=%d"),iServerTail,aServerTail,iClientTail,iClientHead,aNotificationSize);

	//

	//Start Validation

	//

	TBool overflow = EFalse;

	//Check that we have not filled the buffer

    if (aServerTail == iClientHead)

        {

        // Buffer is empty when Client Tail = Client Head

        if (iClientHead != iClientTail)

        	{

			overflow = ETrue;

            return overflow;            

			}

        }

	//Work out remaining size taking account of whether the end position is

	//before or after the overflow position.

	TInt remainingSize = (iClientHead > aServerTail)

			? iClientHead - aServerTail 

			: iClientBufferSize - (aServerTail - iClientHead);

    TInt reservedSize = aNotificationSize;

    // + Save additional space for OVERFLOW

    reservedSize += KNotificationHeaderSize;

	//

    // Have we wrapped around already?

    //

    if (iClientHead > aServerTail)

        {

		// Yes,

		// Buffer looks something like this:

		//

        //            |CH             

        // [5678------1234]

        //     |ST		

		//

		//  Check if we can insert in the middle section:

		//

		if (remainingSize < reservedSize)

			{

			overflow = ETrue;

			}	

		//else:

		// 	{

		// 	We add new notification to middle 

        //	[5678***---1234]

        // 	}

		//

		return overflow;

        }

	//

    // We have not wrapped around yet..

    //

    // Buffer looks something like this:

    //

    //    |CH      

    // [--123456789--]

    //            |ST

    //

	//

    // Check up-front whether its possible for overflow to go at the beginning.

    // If there is not enough space at the start for overflow then we need to

    // check that's there's space for overflow at the end and must not rollover.

    //

    TBool canRollOver = ETrue;

    if (iClientHead < KNotificationHeaderSize)

        {

		//

        //  |CH      

        // [123456789----]

        //          |ST

        //

        // No space for overflow at the beginning of buffer.

        //

        canRollOver = EFalse; 

        }

	//

    // IF: Cannot rollover

    //

    if (!canRollOver)

        {

        //IF (notification + overflow) does not fit at the end overflow now.

        if ((iClientBufferSize - aServerTail) < reservedSize)

            {

            overflow = ETrue;

            }        

        //Else

        //	{

		//	Add notification (**) to end [---12345678**---]

		//	}

        }

    else 

	// Can rollover  

	// - need to check that notification fits at the end

	//   or that notification+overflow fits at the beginning.

        {

        // If not enough space at end, rollover

        if ((iClientBufferSize - aServerTail) < aNotificationSize)

            {

			//

			// Add notification to start and fill end with Filler char 

            // [----0123456789#]

            //

            // IF we are not at the very end of the buffer,

			// insert a KNotificationBufferFiller at iServerTail.

			// When the client reads this, it sets iHead to 0 and reads from there.

			if(iServerTail != iClientBufferSize)

				{

				//If there is space it will always be at least 1 word big

				TPtrC8 fillerDes((TText8*) &KNotificationBufferFiller, sizeof(TUint));

				iBufferMsg.Write(KMsgPtr0, fillerDes, aServerTail);

				}

            // Now that we have rolled over we need to check whether there is

            // space at the beginning for notification + overflow

			// We already know that overflow fits.

            if (reservedSize > iClientHead)

                {

                //  [ov--0123456789-]

                overflow = ETrue;

                }

			//

			// Add notification/overflow to the beginning

			//  	[**--0123456789(#)]

			//

			aServerTail = 0;

			}

		//

		// else - notification fits at the end so there is nothing to do here.

		//

		//

        }

    //

    //End Validation

    //

    return overflow;

    }

// Called from FsNotificationManager::HandleChange().

// Sends notifications into the client's buffer.

// If there is a iClientMsg then this is the first time this

// has been called since the client called RequestNotifications.

// In this situation we complete the client request.

TInt CFsNotifyRequest::NotifyChange(CFsClientMessageRequest* aRequest,const TDesC& aName, TFsNotification::TFsNotificationType aNotificationType, CFsNotificationBlock& aBlock)

	{

	/*

	 * Different notification types have different data associated with them.

	 * 

	 * All types EXCEPT for ERename, EVolumeName and EDriveName have the following data 

	 * and are aligned in the buffer like so:

	 * Word1   : NotificationSize (2 bytes) , PathSize (2 bytes)

	 * Word2   : NotificationType (Lower 2 bytes)

	 * Word(s) : Path (TText8) , [Any sub-class members]

	 * 

	 * Else for notification types ERename, EVolumeName and EDriveName the order is:

	 * Word1   : NotificationSize (2 bytes) , PathSize (2 bytes)

	 * Word2   : NewNameSize (2 bytes) , NotificationType (2 bytes)

	 * Word(s) : Path (TText8) , NewName (TText8)

	 * 

	 * Overflow notification type doesn't have a name, so its namesize is 0

	 * and there will be no Word3.

	 */	

	__PRINT(_L("CFsNotifyRequest::NotifyChange()"));

	TInt notificationSize = FsNotificationHelper::NotificationSize(*aRequest,aNotificationType,aName);

	iClientSyncLock.Wait();

	iTailSemaphore.Wait();

	TInt tail = iServerTail;

	//Validation

	TBool overflow = ValidateNotification(notificationSize, tail);

	//Now that we know there is enough space in the buffer we can write 

	//the standard attributes that all notifications have.

	//We can store the size of the notification 

	//and the size of the name in the same word.

	TUint16 nameLen = 0;	//Overflow has no name

	TInt notifSize = KNotificationHeaderSize;

	if(!overflow)

		{

		nameLen = (TUint16)aName.Size();

		notifSize = notificationSize;

		}

	else 

		{

		aNotificationType = TFsNotification::EOverflow;

		}	

	iServerTail = tail + notifSize;

	iTailSemaphore.Signal();

	TInt writeOffset = 0;	//Where to write in the block

	//Store notification Size and NameSize (Word1)

	TUint sizeNameLen = (notifSize << 16) | nameLen;	

	memcpy((TText8*)aBlock.Data()+writeOffset,&sizeNameLen,sizeof(TUint));

	writeOffset+=sizeof(TUint);

	TPtrC newName;

	if (aNotificationType == TFsNotification::ERename ||

		aNotificationType == TFsNotification::EVolumeName ||

		aNotificationType == TFsNotification::EDriveName)

		{

		FsNotificationHelper::NewPathName(*aRequest,newName);

		//Store NewNameSize and notification Type (Word2)

		TUint typeNewNameLen = ((TUint16)newName.Size() << 16) | (TUint16)aNotificationType;

		memcpy((TText8*)aBlock.Data()+writeOffset,&typeNewNameLen,sizeof(TUint));

		}

	else

		{

		//Store notification Type (Word2)

		memcpy((TText8*)aBlock.Data()+writeOffset,&aNotificationType,sizeof(TUint));

		}

	writeOffset+=sizeof(TUint);

	CFileShare* share = NULL;

    CFileCB* file = NULL;

    if(aRequest) //Don't always have a request such as when called from localdrives.

        {

        GetFileFromScratch(aRequest, share, file);

        }

    //

    //Store UID

    /*

	TUid uid;

	uid.iUid = KErrUnknown;

	if(aRequest && aRequest->Operation()->iFunction == EFsFileWriteDirty)

	    {

	    uid = aRequest->iUID;

	    }