--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/sfile/sf_notifier.cpp Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,1294 @@
+// 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;
+ }
+ else if(aRequest)
+ {
+ uid = aRequest->Message().Identity();
+ }
+ memcpy((TText8*)aBlock.Data()+writeOffset,&uid.iUid,sizeof(TUint32));
+ writeOffset+=sizeof(TUint32);
+ */
+
+ if(!overflow)
+ {
+ //Store Name (Word3)
+ memcpy((TText8*)aBlock.Data()+writeOffset,aName.Ptr(),aName.Size());
+ writeOffset += Align4(aName.Size());
+
+
+ switch (aNotificationType)
+ {
+ case TFsNotification::EFileChange:
+ {
+ TInt64 size = 0;
+ size = file->CachedSize64();
+ memcpy((TText8*)aBlock.Data()+writeOffset,&size,sizeof(TInt64));
+ writeOffset += sizeof(TInt64);
+ break;
+ }
+ case TFsNotification::ERename:
+ case TFsNotification::EVolumeName:
+ case TFsNotification::EDriveName:
+ {
+ //Store NewName
+ memcpy((TText8*)aBlock.Data()+writeOffset,newName.Ptr(),newName.Size());
+ writeOffset += Align4(newName.Size());
+ break;
+ }
+ case TFsNotification::EAttribute:
+ {
+ TUint set=0;
+ TUint clear=0;
+ FsNotificationHelper::Attributes(*aRequest,set,clear);
+ TUint64 att = MAKE_TUINT64(set,clear);
+ memcpy((TText8*)aBlock.Data()+writeOffset,&att,sizeof(TUint64));
+ writeOffset += sizeof(TUint64);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ //Write to client buffer
+ TInt r = SynchroniseBuffer(aBlock,tail,notifSize);
+
+ //Signal the iClientSyncLock.
+ //When all locks on this are signaled then CompleteClientRequest can be called.
+ //This signal moves when we have a cache system
+ iClientSyncLock.Signal();
+
+ //We need to complete if this was the first
+ //write to the client's buffer
+ if (r == KErrNone)
+ {
+ //We need to complete if this was the first
+ //write to the client's buffer
+ if(ClientMsgHandle()!=0)
+ {
+ //RDebug::Print(_L("CFsNotifyRequest::NotifyChange iClientHead(%d) iClientTail(%d) iServerTail(%d) iClientBufferSize(%d)"),iClientHead,iClientTail,iServerTail,iClientBufferSize);
+ __PRINT4(_L("CFsNotifyRequest::NotifyChange iClientHead(%d) iClientTail(%d) iServerTail(%d) iClientBufferSize(%d)"),iClientHead,iClientTail,iServerTail,iClientBufferSize);
+ CompleteClientRequest(KErrNone);
+ }
+ else if(!overflow)
+ {
+ SetActive(CFsNotifyRequest::EOutstanding);
+ }
+ else //Overflow
+ {
+ SetActive(CFsNotifyRequest::EOutstandingOverflow);
+ }
+ }
+ else // r!=KErrNone
+ {
+ //RDebug::Print(_L("sf_notifier.cpp line %d function = %d, r = %d"),__LINE__, aRequest->FsFunction(),r);
+ //RDebug::Print(_L("iServerTail=%d, tail=%d, iClientBufferSize=%d, overflow=%d"),iServerTail,tail,iClientBufferSize,overflow);
+ }
+ return r;
+ }
+
+#ifdef SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION
+
+//A change has occurred in f32 represented by this
+//request object. Work out which CfsNotify’s are interested
+// (if any) and call CfsNotifyRequest::NotifyChange.
+void FsNotificationManager::HandleChange(CFsClientMessageRequest* aRequest,const TDesC& aOperationName, TFsNotification::TFsNotificationType aType)
+ {
+ __PRINT2(_L("FsNotificationManager::HandleChange() aRequest=0x%x, aType=%d"),&aRequest,aType);
+
+ Lock(); //ToDo: Read Lock (Read/Write Lock)
+ if(Count())
+ {
+ //Only search while there are filters of this type set up.
+ TInt index = FsNotificationHelper::TypeToIndex(aType);
+ TInt& filterCount = FsNotificationManager::FilterRegister(index);
+ TInt seenFilter = filterCount; //Number of requests set up for this type
+
+ //Iterate CFsNotifyRequests
+ TInt count = iNotifyRequests->Count();
+
+ if(aType == TFsNotification::EMediaChange)
+ seenFilter = count;
+
+ //If there aren't any requests then breakout
+ if(count == 0)
+ {
+ Unlock();
+ return;
+ }
+
+ TInt driveNum = FsNotificationHelper::DriveNumber(aOperationName);
+
+ //For every notification request.
+ for(TInt i=0; i<count && seenFilter; ++i)
+ {
+ CFsNotifyRequest* notifyRequest = (CFsNotifyRequest*)(*iNotifyRequests)[i];
+ CFsNotifyRequest::TNotifyRequestStatus status = notifyRequest->ActiveStatus();
+ if(! (status==CFsNotifyRequest::EActive ||
+ status==CFsNotifyRequest::EOutstanding))
+ {
+ //Not active; check next notification request
+ continue;
+ }
+
+ //Check whether we are interested in this change.
+ //Get the filters associated with this operation on this drive
+ TFsNotificationTypeArray* filterList = notifyRequest->FilterTypeList(driveNum,index);
+ DoHandleChange(filterList,seenFilter,aRequest,notifyRequest,aOperationName,aType);
+
+ if(aType==TFsNotification::EMediaChange)
+ continue; //next request
+
+ //If there are still filters to check
+ if(seenFilter)
+ {
+ //Check changes that are not tied to a particular drive
+ filterList = notifyRequest->FilterTypeList(KErrNotFound,index);
+ DoHandleChange(filterList,seenFilter,aRequest,notifyRequest,aOperationName,aType);
+ }
+ }
+ }
+ Unlock();
+ }
+
+//A change has occurred in f32 represented by this
+//request object. Work out which CfsNotify’s are interested
+// (if any) and call CfsNotifyRequest::NotifyChange.
+void FsNotificationManager::HandleChange(CFsClientMessageRequest& aRequest, TFsNotification::TFsNotificationType aType)
+ {
+ __PRINT(_L("FsNotificationManager::HandleChange"));
+ TFileName currentOperationsName;
+ FsNotificationHelper::PathName(aRequest, currentOperationsName);
+ if(currentOperationsName.Length())
+ HandleChange(&aRequest,currentOperationsName,aType);
+ }
+
+//A change has occurred in f32 represented by this
+//request object. Work out which CfsNotify’s are interested
+// (if any) and call CfsNotifyRequest::NotifyChange.
+void FsNotificationManager::HandleChange(CFsClientMessageRequest& aRequest)
+ {
+ if(Count() && aRequest.Message().Handle() != KLocalMessageHandle)
+ {
+ __PRINT(_L("FsNotificationManager::HandleChange"));
+ TFsNotification::TFsNotificationType operationNotificationType;
+ FsNotificationHelper::NotificationType(aRequest.FsFunction(), operationNotificationType);
+ HandleChange(aRequest,operationNotificationType);
+ }
+ }
+
+
+////
+#else
+////
+
+void FsNotificationManager::HandleChange(CFsClientMessageRequest* ,const TDesC&, TFsNotification::TFsNotificationType)
+ {
+ return;
+ }
+
+void FsNotificationManager::HandleChange(CFsClientMessageRequest& , TFsNotification::TFsNotificationType)
+ {
+ return;
+ }
+
+void FsNotificationManager::HandleChange(CFsClientMessageRequest&)
+ {
+ return;
+ }
+
+#endif //SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION
+
+//Called from FsNotificationManager::DoHandleChange
+FsNotificationManager::TFsNotificationFilterMatch FsNotificationManager::DoMatchFilter(CFsClientMessageRequest* aRequest, const TDesC& aOperationName,CFsNotificationPathFilter& aFilter)
+ {
+ TFsNotificationFilterMatch filterMatch = EDifferent;
+ TParsePtrC parseOp(aOperationName);
+ TPtrC pathOpDes = parseOp.DriveAndPath();
+ TPtrC nameOpDes = parseOp.NameAndExt();
+ TInt pathLength = aFilter.iPath->Des().Length();
+ TInt nameLength = aFilter.iFilename->Des().Length();
+ TInt paths = -1;
+ TInt names = -1;
+ if(pathLength != 0)
+ {
+ paths = pathOpDes.MatchF(aFilter.iPath->Des());
+ }
+ else //if no path filter was set up
+ // then we need to ensure we don't notify on data-caged areas which we shouldn't
+ {
+ TInt r = PathCheck(aRequest,aOperationName.Mid(2),&KCapFsSysFileTemp,&KCapFsPriFileTemp,&KCapFsROFileTemp, __PLATSEC_DIAGNOSTIC_STRING("FsNotificationManager::DoHandleChange"));
+ if(r != KErrNone)
+ return EContinue; //next filter
+ }
+
+ if(nameLength != 0)
+ {
+ names = nameOpDes.MatchF(aFilter.iFilename->Des());
+ }
+ //Check: Path & Names Match
+ if((paths == 0 || pathLength==0) && // paths match &&
+ (names >= 0 || (nameLength==0 && nameOpDes.Length()==0))) // names match OR there are no names (i.e. operation is a dir and no filename filter)
+ {
+ filterMatch = EMatch;
+ }
+ return filterMatch;
+ }
+
+// This is called on a per drive basis.
+void FsNotificationManager::DoHandleChange(TFsNotificationTypeArray* aFilterTypeArray,TInt& aSeenFilter, CFsClientMessageRequest* aRequest, CFsNotifyRequest* aNotifyRequest, const TDesC& aOperationName, TFsNotification::TFsNotificationType& aType)
+ {
+ __PRINT(_L("FsNotificationManager::DoHandleChange()"));
+
+ if(!aFilterTypeArray)
+ return;
+
+ TInt numFilters = aFilterTypeArray->Count();
+
+ if(aType == TFsNotification::EMediaChange)
+ numFilters = 1; //Only need to notify once per drive.
+
+ //For every filter in this request
+ for(TInt j = 0; j < numFilters;++j)
+ {
+ //Is the correct notification type
+ aSeenFilter--;
+
+ TBool filterMatch = EDifferent;
+ if(aType != TFsNotification::EMediaChange)
+ {
+ CFsNotificationPathFilter& filter = *(((*aFilterTypeArray)[j]).iPathFilter);
+ __PRINT2(_L("FsNotificationManager::DoHandleChange() operationName=%S, filterName=%S"),&aOperationName,filter.iPath);
+
+ filterMatch = DoMatchFilter(aRequest,aOperationName,filter);
+ if(filterMatch == FsNotificationManager::EContinue)
+ continue; //triggers for data cages
+
+ //We need to check for changes coming in to a directory when its rename
+ if(aType == TFsNotification::ERename && filterMatch==FsNotificationManager::EDifferent)
+ {
+ TPtrC aDestinationNamePtrC;
+ FsNotificationHelper::NewPathName(*aRequest,aDestinationNamePtrC);
+ __PRINT2(_L("FsNotificationManager::DoHandleChange() destinationName=%S, filterName=%S"),&aDestinationNamePtrC,filter.iPath);
+ filterMatch = DoMatchFilter(aRequest,aDestinationNamePtrC,filter);
+ }
+ }
+
+ if(filterMatch || (aType == TFsNotification::EMediaChange))//Match or MediaChange (report regardless of filters)
+ {
+ //Matching - Handle change
+
+ //Get a CFsNotificationBlock to use
+ //So that we can do IPC from a single place.
+ CFsNotificationBlock* block = iPool->Allocate();
+
+ TInt r = aNotifyRequest->NotifyChange(aRequest,aOperationName,aType,*block);
+
+ //Free block
+ iPool->Free(block);
+
+ if(r != KErrNone)
+ {
+ //Something went wrong writing to the client's buffer
+ aNotifyRequest->SetActive(CFsNotifyRequest::EInactive);
+ if(aNotifyRequest->ClientMsgHandle()!=0)
+ aNotifyRequest->CompleteClientRequest(r,EFalse);
+ break; //Go to outer for (i.e. next request in HandleChange)
+ }
+ }
+ continue; //next filter
+ }
+ }