diff options
| -rw-r--r-- | Bus/IvyFileMon/DirectoryChanges.cpp | 2026 |
1 files changed, 2026 insertions, 0 deletions
diff --git a/Bus/IvyFileMon/DirectoryChanges.cpp b/Bus/IvyFileMon/DirectoryChanges.cpp new file mode 100644 index 0000000..10b88b3 --- /dev/null +++ b/Bus/IvyFileMon/DirectoryChanges.cpp @@ -0,0 +1,2026 @@ +// DirectoryChanges.cpp: implementation of the CDirectoryChangeWatcher and CDirectoryChangeHandler classes.
+//
+///////////////////////////////////////////////////////////////////
+///
+
+/***********************************************************
+
+ Author: Wes Jones wesj@hotmail.com
+
+ File: DirectoryChanges.cpp
+
+ Latest Changes:
+
+ 11/22/2001 -- Fixed bug causing file name's to be truncated if
+ longer than 130 characters. Fixed CFileNotifyInformation::GetFileName()
+ Thanks to Edric(uo_edric@hotmail.com) for pointing this out.
+
+ Added code to enable process privileges when CDirectoryChangeWatcher::WatchDirectory()
+ is first called. See docuementation API for ReadDirectoryChangesW() for more information of required privileges.
+
+ Currently enables these privileges: (11/22/2001)
+ SE_BACKUP_NAME
+ SE_CHANGE_NOTIFY_NAME
+ SE_RESTORE_NAME(02/09/2002)
+ Implemented w/ helper class CPrivilegeEnabler.
+
+ 11/23/2001 Added classes so that all notifications are handled by the
+ same thread that called CDirectoryChangeWatcher::WatchDirectory(),
+ ie: the main thread.
+ CDirectoryChangeHandler::On_Filexxxx() functions are now called in the
+ context of the main thread instead of the worker thread.
+
+ This is good for two reasons:
+ 1: The worker thread spends less time handling each notification.
+ The worker thread simply passes the notification to the main thread,
+ which does the processing.
+ This means that each file change notification is handled as fast as possible
+ and ReadDirectoryChangesW() can be called again to receive more notifications
+ faster.
+
+ 2: This makes it easier to make an ActiveX or ATL object with this class
+ because the events that are fired, fire in the context of the main thread.
+ The fact that I'm using a worker thread w/ this class is totally
+ transparent to a client user.
+ If I decide to turn this app into an ActiveX or ATL object
+ I don't have to worry about wierd COM rules and multithreading issues,
+ and neither does the client, be the client a VB app, C++ app, Delphi app, or whatever.
+
+ Implemented with CDelayedDirectoryChangeHandler in DirectoryChangeHandler.h/.cpp
+
+ 02/06/2002 Fixed a bug that would cause an application to hang.
+ If ReadDirectoryChangesW was to fail during normal operation,
+ the short story is that the application would hang
+ when it called CDirectoryChangeWatcher::UnwatchDirectory(const CString & )
+
+ One way to reproduce this behavior on the old code
+ is to watch a directory using a UNC path, and then change the IP
+ address of that machine while the watch was running. Exitting
+ the app after this would cause it to hang.
+
+ Steps to reproduce it:
+
+ 1) Assume that the computer running the code is
+ named 'ThisComputer' and there is a shared folder named 'FolderName'
+
+
+ 2) Start a watch on a folder using a UNC path: ie: \\ThisComputer\FolderName
+
+ eg: CDirectoryChangeWatcher watcher;
+
+ watcher.WatchDirectory(_T("\\\\ThisComputer\\FolderName",/ * other parameters * /)
+
+ 3) Change the IP address of 'ThisComputer'
+
+ ** ReadDirectoryChangesW() will fail some point after this.
+
+
+ 4) Exit the application... it may hang.
+
+
+ Anyways, that's what the bug fix is for.
+
+
+ 02/06/2002 New side effects for CDirectoryChangeHandler::On_ReadDirectoryChangeError()
+
+ If CDirectoryChangeHandler::On_ReadDirectoryChangeError() is ever executed
+ the directory that you are watching will have been unwatched automatically due
+ to the error condition.
+
+ A call to CDirectoryChangeWatcher::IsWatchingDirectory() will fail because the directory
+ is no longer being watched. You'll need to re-watch that directory.
+
+ 02/09/2002 Added a parameter to CDirectoryChangeHandler::On_ReadDirectoryChangeError()
+
+ Added the parameter: const CString & strDirectoryName
+ The new signature is now:
+ virtual void CDirectoryChangeHandler::On_ReadDirectoryChangeError(DWORD dwError, const CString & strDirectoryName);
+
+ This new parameter gives you the name of the directory that the error occurred on.
+
+ 04/25/2002 Provided a way to get around the requirement of a message pump.
+ A console app can now use this w/out problems by passing false
+ to the constructor of CDirectoryChangeWatcher.
+ An app w/ a message pump can also pass false if it so desires w/out problems.
+
+ 04/25/2002 Added two new virtual functions to CDirectoryChangeHandler
+
+ Added:
+ On_WatchStarted(DWORD dwError, const CString & strDirectoryName)
+ On_WatchStopped(const CString & strDirectoryName);
+ See header file for details.
+
+ 04/27/2002 Added new function to CDirectoryChangeHandler:
+
+ Added virtual bool On_FilterNotification(DWORD dwNotifyAction, LPCTSTR szFileName, LPCTSTR szNewFileName)
+
+ This function is called before any notification function, and allows the
+ CDirectoryChangeHandler derived class to ignore file notifications
+ by performing a programmer defined test.
+ By ignore, i mean that
+ On_FileAdded(), On_FileRemoved(), On_FileModified(), or On_FileNameChanged()
+ will NOT be called if this function returns false.
+
+ The default implementation always returns true, signifying that ALL notifications
+ are to be called.
+
+
+ 04/27/2002 Added new Parameters to CDirectoryChangeWatcher::WatchDirectory()
+
+ The new parameters are:
+ LPCTSTR szIncludeFilter
+ LPCTSTR szExcludeFilter
+ Both parameters are defaulted to NULL.
+ Signature is now:
+ CDirectoryChangeWatcher::WatchDirectory(const CString & strDirToWatch,
+ DWORD dwChangesToWatchFor,
+ CDirectoryChangeHandler * pChangeHandler,
+ BOOL bWatchSubDirs = FALSE,
+ LPCTSTR szIncludeFilter = NULL,
+ LPCTSTR szExcludeFilter = NULL)
+
+ 04/27/2002 Added support for include and exclude filters.
+ These filters allow you to receive notifications for just the files you
+ want... ie: you can specify that you only want to receive notifications
+ for changes to "*.txt" files or some other such file filter.
+
+ NOTE: This feature is implemented w/ the PathMatchSpec() api function
+ which is only available on NT4.0 if Internet Explorer 4.0 or above is installed.
+ See MSDN for PathMatchSpec(). Win2000, and XP do not have to worry about it.
+
+ Filter specifications:
+ Accepts wild card characters * and ?, just as you're used to for the DOS dir command.
+ It is possible to specify multiple extenstions in the filter by separating each filter spec
+ with a semi-colon.
+ eg: "*.txt;*.tmp;*.log" <-- this filter specifies all .txt, .tmp, & .log files
+
+
+
+ Filters are passed as parameters to CDirectoryChangeWatcher::WatchDirectory()
+
+ NOTE: The filters you specify take precedence over CDirectoryChangeHandler::On_FilterNotification().
+ This means that if the file name does not pass the filters that you specify
+ when the watch is started, On_FilterNotification() will not be called.
+ Filter specifications are case insensitive, ie: ".tmp" and ".TMP" are the same
+
+
+ FILTER TYPES:
+ Include Filter:
+ If you specify an include filter, you are specifying that you
+ only want to receive notifications for specific file types.
+ eg: "*.log" means that you only want notifications for changes
+ to files w/ an exention of ".log".
+ Changes to ALL OTHER other file types are ignored.
+ An empty, or not specified include filter means that you want
+ notifications for changes of ALL file types.
+ Exclude filter:
+
+ If you specify an exclude filter, you are specifying that
+ you do not wish to receive notifications for a specific type of file or files.
+ eg: "*.tmp" would mean that you do not want any notifications
+ regarding files that end w/ ".tmp"
+ An empty, or not specified exclude filter means that
+ you do not wish to exclude any file notifications.
+
+
+
+
+
+
+
+************************************************************/
+
+#include "stdafx.h"
+#include "DirectoryChanges.h"
+#include "DelayedDirectoryChangeHandler.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+#define new DEBUG_NEW
+#endif
+//
+//
+// Fwd Declares & #define's
+//
+//
+//
+// Helper classes
+class CPrivilegeEnabler; //for use w/ enabling process priveledges when this code is first used. It's a singleton.
+
+class CFileNotifyInformation;//helps CDirectoryChangeWatcher class notify CDirectoryChangeHandler class of changes to files.
+
+class CDelayedDirectoryChangeHandler; // Helps all notifications become handled by the main
+ // thread, or a worker thread depending upon a value passed to the
+ // constructor of CDirectoryChangeWatcher.
+ //
+ // For notifications to fire in the main thread, your app must have a message pump.
+ //
+ // The 'main' thread is the one that called CDirectoryChangeWatcher::WatchDirectory()
+
+// Helper functions
+static BOOL EnablePrivilege(LPCTSTR pszPrivName, BOOL fEnable = TRUE);
+static bool IsDirectory(const CString & strPath);
+/////////////////////////////////////////////////////////////////////
+// Helper functions.
+BOOL EnablePrivilege(LPCTSTR pszPrivName, BOOL fEnable /*= TRUE*/)
+//
+// I think this code is from a Jeffrey Richter book...
+//
+// Enables user priviledges to be set for this process.
+//
+// Process needs to have access to certain priviledges in order
+// to use the ReadDirectoryChangesW() API. See documentation.
+{
+ BOOL fOk = FALSE;
+ // Assume function fails
+ HANDLE hToken;
+ // Try to open this process's access token
+ if (OpenProcessToken(GetCurrentProcess(),
+ TOKEN_ADJUST_PRIVILEGES, &hToken))
+ {
+ // privilege
+ TOKEN_PRIVILEGES tp = { 1 };
+
+ if( LookupPrivilegeValue(NULL, pszPrivName, &tp.Privileges[0].Luid) )
+ {
+ tp.Privileges[0].Attributes = fEnable ? SE_PRIVILEGE_ENABLED : 0;
+
+ AdjustTokenPrivileges(hToken, FALSE, &tp,
+ sizeof(tp), NULL, NULL);
+
+ fOk = (GetLastError() == ERROR_SUCCESS);
+ }
+ CloseHandle(hToken);
+ }
+ return(fOk);
+}
+
+static bool IsDirectory(const CString & strPath)
+//
+// Returns: bool
+// true if strPath is a path to a directory
+// false otherwise.
+//
+{
+ DWORD dwAttrib = GetFileAttributes( strPath );
+ return static_cast<bool>( ( dwAttrib != 0xffffffff
+ && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) );
+
+
+}
+///////////////////////////////////////////////
+//Helper class:
+
+class CFileNotifyInformation
+/*******************************
+
+A Class to more easily traverse the FILE_NOTIFY_INFORMATION records returned
+by ReadDirectoryChangesW().
+
+FILE_NOTIFY_INFORMATION is defined in Winnt.h as:
+
+ typedef struct _FILE_NOTIFY_INFORMATION {
+ DWORD NextEntryOffset;
+ DWORD Action;
+ DWORD FileNameLength;
+ WCHAR FileName[1];
+} FILE_NOTIFY_INFORMATION, *PFILE_NOTIFY_INFORMATION;
+
+ ReadDirectoryChangesW basically puts x amount of these records in a
+ buffer that you specify.
+ The FILE_NOTIFY_INFORMATION structure is a 'dynamically sized' structure (size depends on length
+ of the file name (+ sizeof the DWORDs in the struct))
+
+ Because each structure contains an offset to the 'next' file notification
+ it is basically a singly linked list. This class treats the structure in that way.
+
+
+ Sample Usage:
+ BYTE Read_Buffer[ 4096 ];
+
+ ...
+ ReadDirectoryChangesW(...Read_Buffer, 4096,...);
+ ...
+
+ CFileNotifyInformation notify_info( Read_Buffer, 4096);
+ do{
+ switch( notify_info.GetAction() )
+ {
+ case xx:
+ notify_info.GetFileName();
+ }
+
+ while( notify_info.GetNextNotifyInformation() );
+
+********************************/
+{
+public:
+ CFileNotifyInformation( BYTE * lpFileNotifyInfoBuffer, DWORD dwBuffSize)
+ : m_pBuffer( lpFileNotifyInfoBuffer ),
+ m_dwBufferSize( dwBuffSize )
+ {
+ ASSERT( lpFileNotifyInfoBuffer && dwBuffSize );
+
+ m_pCurrentRecord = (PFILE_NOTIFY_INFORMATION) m_pBuffer;
+ }
+
+
+ BOOL GetNextNotifyInformation();
+
+ BOOL CopyCurrentRecordToBeginningOfBuffer(OUT DWORD & ref_dwSizeOfCurrentRecord);
+
+ DWORD GetAction() const;//gets the type of file change notifiation
+ CString GetFileName()const;//gets the file name from the FILE_NOTIFY_INFORMATION record
+ CString GetFileNameWithPath(const CString & strRootPath) const;//same as GetFileName() only it prefixes the strRootPath into the file name
+
+
+protected:
+ BYTE * m_pBuffer;//<--all of the FILE_NOTIFY_INFORMATION records 'live' in the buffer this points to...
+ DWORD m_dwBufferSize;
+ PFILE_NOTIFY_INFORMATION m_pCurrentRecord;//this points to the current FILE_NOTIFY_INFORMATION record in m_pBuffer
+
+};
+
+BOOL CFileNotifyInformation::GetNextNotifyInformation()
+/***************
+ Sets the m_pCurrentRecord to the next FILE_NOTIFY_INFORMATION record.
+
+ Even if this return FALSE, (unless m_pCurrentRecord is NULL)
+ m_pCurrentRecord will still point to the last record in the buffer.
+****************/
+{
+ if( m_pCurrentRecord
+ && m_pCurrentRecord->NextEntryOffset != 0UL)//is there another record after this one?
+ {
+ //set the current record to point to the 'next' record
+ PFILE_NOTIFY_INFORMATION pOld = m_pCurrentRecord;
+ m_pCurrentRecord = (PFILE_NOTIFY_INFORMATION) ((LPBYTE)m_pCurrentRecord + m_pCurrentRecord->NextEntryOffset);
+
+ ASSERT( (DWORD)((BYTE*)m_pCurrentRecord - m_pBuffer) < m_dwBufferSize);//make sure we haven't gone too far
+
+ if( (DWORD)((BYTE*)m_pCurrentRecord - m_pBuffer) > m_dwBufferSize )
+ {
+ //we've gone too far.... this data is hosed.
+ //
+ // This sometimes happens if the watched directory becomes deleted... remove the FILE_SHARE_DELETE flag when using CreateFile() to get the handle to the directory...
+ m_pCurrentRecord = pOld;
+ }
+
+ return (BOOL)(m_pCurrentRecord != pOld);
+ }
+ return FALSE;
+}
+
+BOOL CFileNotifyInformation::CopyCurrentRecordToBeginningOfBuffer(OUT DWORD & ref_dwSizeOfCurrentRecord)
+/*****************************************
+ Copies the FILE_NOTIFY_INFORMATION record to the beginning of the buffer
+ specified in the constructor.
+
+ The size of the current record is returned in DWORD & dwSizeOfCurrentRecord.
+
+*****************************************/
+{
+ ASSERT( m_pBuffer && m_pCurrentRecord );
+ if( !m_pCurrentRecord ) return FALSE;
+
+ BOOL bRetVal = TRUE;
+
+ //determine the size of the current record.
+ ref_dwSizeOfCurrentRecord = sizeof( FILE_NOTIFY_INFORMATION );
+ //subtract out sizeof FILE_NOTIFY_INFORMATION::FileName[1]
+ WCHAR FileName[1];//same as is defined for FILE_NOTIFY_INFORMATION::FileName
+ UNREFERENCED_PARAMETER(FileName);
+ ref_dwSizeOfCurrentRecord -= sizeof(FileName);
+ //and replace it w/ value of FILE_NOTIFY_INFORMATION::FileNameLength
+ ref_dwSizeOfCurrentRecord += m_pCurrentRecord->FileNameLength;
+
+ ASSERT( (DWORD)((LPBYTE)m_pCurrentRecord + ref_dwSizeOfCurrentRecord) <= m_dwBufferSize );
+
+ ASSERT( (void*)m_pBuffer != (void*)m_pCurrentRecord );//if this is the case, your buffer is way too small
+ if( (void*)m_pBuffer != (void*) m_pCurrentRecord )
+ {//copy the m_pCurrentRecord to the beginning of m_pBuffer
+
+ ASSERT( (DWORD)m_pCurrentRecord > (DWORD)m_pBuffer + ref_dwSizeOfCurrentRecord);//will it overlap?
+ __try{
+ memcpy(m_pBuffer, m_pCurrentRecord, ref_dwSizeOfCurrentRecord);
+ bRetVal = TRUE;
+ }
+ __except(EXCEPTION_EXECUTE_HANDLER)
+ {
+ TRACE(_T("EXCEPTION! CFileNotifyInformation::CopyCurrentRecordToBeginningOfBuffer() -- probably because bytes overlapped in a call to memcpy()"));
+ bRetVal = FALSE;
+ }
+ }
+ //else
+ //there was only one record in this buffer, and m_pCurrentRecord is already at the beginning of the buffer
+ return bRetVal;
+}
+
+DWORD CFileNotifyInformation::GetAction() const
+{
+ ASSERT( m_pCurrentRecord );
+ if( m_pCurrentRecord )
+ return m_pCurrentRecord->Action;
+ return 0UL;
+}
+
+CString CFileNotifyInformation::GetFileName() const
+{
+ //
+ //BUG FIX:
+ // File Name's longer than 130 characters are truncated
+ //
+ // Thanks Edric @ uo_edric@hotmail.com for pointing this out.
+ if( m_pCurrentRecord )
+ {
+ WCHAR wcFileName[ MAX_PATH + 1] = {0};//L"";
+ memcpy( wcFileName,
+ m_pCurrentRecord->FileName,
+ //min( MAX_PATH, m_pCurrentRecord->FileNameLength) <-- buggy line
+ min( (MAX_PATH * sizeof(WCHAR)), m_pCurrentRecord->FileNameLength));
+
+
+ return CString( wcFileName );
+ }
+ return CString();
+}
+
+static inline bool HasTrailingBackslash(const CString & str )
+{
+ if( str.GetLength() > 0
+ && str[ str.GetLength() - 1 ] == _T('\\') )
+ return true;
+ return false;
+}
+CString CFileNotifyInformation::GetFileNameWithPath(const CString & strRootPath) const
+{
+ CString strFileName( strRootPath );
+ //if( strFileName.Right(1) != _T("\\") )
+ if( !HasTrailingBackslash( strRootPath ) )
+ strFileName += _T("\\");
+
+ strFileName += GetFileName();
+ return strFileName;
+}
+/////////////////////////////////////////////////////////////////////////////////
+class CPrivilegeEnabler
+//
+// Enables privileges for this process
+// first time CDirectoryChangeWatcher::WatchDirectory() is called.
+//
+// It's a singleton.
+//
+{
+private:
+ CPrivilegeEnabler();//ctor
+public:
+ ~CPrivilegeEnabler(){};
+
+ static CPrivilegeEnabler & Instance();
+ //friend static CPrivilegeEnabler & Instance();
+};
+
+CPrivilegeEnabler::CPrivilegeEnabler()
+{
+ LPCTSTR arPrivelegeNames[] = {
+ SE_BACKUP_NAME, // these two are required for the FILE_FLAG_BACKUP_SEMANTICS flag used in the call to
+ SE_RESTORE_NAME,// CreateFile() to open the directory handle for ReadDirectoryChangesW
+
+ SE_CHANGE_NOTIFY_NAME //just to make sure...it's on by default for all users.
+ //<others here as needed>
+ };
+ for(int i = 0; i < sizeof(arPrivelegeNames) / sizeof(arPrivelegeNames[0]); ++i)
+ {
+ if( !EnablePrivilege(arPrivelegeNames[i], TRUE) )
+ {
+ TRACE(_T("Unable to enable privilege: %s -- GetLastError(): %d\n"), arPrivelegeNames[i], GetLastError());
+ TRACE(_T("CDirectoryChangeWatcher notifications may not work as intended due to insufficient access rights/process privileges.\n"));
+ TRACE(_T("File: %s Line: %d\n"), _T(__FILE__), __LINE__);
+ }
+ }
+}
+
+CPrivilegeEnabler & CPrivilegeEnabler::Instance()
+{
+ static CPrivilegeEnabler theInstance;//constructs this first time it's called.
+ return theInstance;
+}
+//
+//
+//
+///////////////////////////////////////////////////////////
+
+
+//
+//
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+CDirectoryChangeHandler::CDirectoryChangeHandler()
+: m_nRefCnt( 1 ),
+ m_pDirChangeWatcher( NULL ),
+ m_nWatcherRefCnt( 0L )
+{
+}
+
+CDirectoryChangeHandler::~CDirectoryChangeHandler()
+{
+ UnwatchDirectory();
+}
+
+long CDirectoryChangeHandler::AddRef()
+{
+ return InterlockedIncrement(&m_nRefCnt);
+}
+
+long CDirectoryChangeHandler::Release()
+{
+ long nRefCnt = -1;
+ if( (nRefCnt = InterlockedDecrement(&m_nRefCnt)) == 0 )
+ delete this;
+ return nRefCnt;
+}
+long CDirectoryChangeHandler::CurRefCnt()const
+{
+ return m_nRefCnt;
+}
+
+BOOL CDirectoryChangeHandler::UnwatchDirectory()
+{
+ CSingleLock lock(&m_csWatcher, TRUE);
+ ASSERT( lock.IsLocked() );
+
+ if( m_pDirChangeWatcher )
+ return m_pDirChangeWatcher->UnwatchDirectory( this );
+ return TRUE;
+}
+
+long CDirectoryChangeHandler::ReferencesWatcher(CDirectoryChangeWatcher * pDirChangeWatcher)
+{
+ ASSERT( pDirChangeWatcher );
+ CSingleLock lock(&m_csWatcher, TRUE);
+ if( m_pDirChangeWatcher
+ && m_pDirChangeWatcher != pDirChangeWatcher )
+ {
+ TRACE(_T("CDirectoryChangeHandler...is becoming used by a different CDirectoryChangeWatcher!\n"));
+ TRACE(_T("Directories being handled by this object will now be unwatched.\nThis object is now being used to ")
+ _T("handle changes to a directory watched by different CDirectoryChangeWatcher object, probably on a different directory"));
+
+ if( UnwatchDirectory() )
+ {
+ m_pDirChangeWatcher = pDirChangeWatcher;
+ m_nWatcherRefCnt = 1; //when this reaches 0, set m_pDirChangeWatcher to NULL
+ return m_nWatcherRefCnt;
+ }
+ else
+ {
+ ASSERT( FALSE );//shouldn't get here!
+ }
+ }
+ else
+ {
+ ASSERT( !m_pDirChangeWatcher || m_pDirChangeWatcher == pDirChangeWatcher );
+
+ m_pDirChangeWatcher = pDirChangeWatcher;
+
+ if( m_pDirChangeWatcher )
+ return InterlockedIncrement(&m_nWatcherRefCnt);
+
+ }
+ return m_nWatcherRefCnt;
+}
+
+long CDirectoryChangeHandler::ReleaseReferenceToWatcher(CDirectoryChangeWatcher * pDirChangeWatcher)
+{
+ ASSERT( m_pDirChangeWatcher == pDirChangeWatcher );
+ CSingleLock lock(&m_csWatcher, TRUE);
+ long nRef;
+ if( (nRef = InterlockedDecrement(&m_nWatcherRefCnt)) <= 0L )
+ {
+ m_pDirChangeWatcher = NULL; //Setting this to NULL so that this->UnwatchDirectory() which is called in the dtor
+ //won't call m_pDirChangeWatcher->UnwatchDirecotry(this).
+ //m_pDirChangeWatcher may point to a destructed object depending on how
+ //these classes are being used.
+ m_nWatcherRefCnt = 0L;
+ }
+ return nRef;
+}
+
+//
+//
+// Default implmentations for CDirectoryChangeHandler's virtual functions.
+//
+//
+void CDirectoryChangeHandler::On_FileAdded(const CString & strFileName)
+{
+ TRACE(_T("The following file was added: %s\n"), strFileName);
+}
+
+void CDirectoryChangeHandler::On_FileRemoved(const CString & strFileName)
+{
+ TRACE(_T("The following file was removed: %s\n"), strFileName);
+}
+
+void CDirectoryChangeHandler::On_FileModified(const CString & strFileName)
+{
+ TRACE(_T("The following file was modified: %s\n"), strFileName);
+}
+
+void CDirectoryChangeHandler::On_FileNameChanged(const CString & strOldFileName, const CString & strNewFileName)
+{
+ TRACE(_T("The file %s was RENAMED to %s\n"), strOldFileName, strNewFileName);
+}
+void CDirectoryChangeHandler::On_ReadDirectoryChangesError(DWORD dwError, const CString & strDirectoryName)
+{
+ TRACE(_T("WARNING!!!!!\n") );
+ TRACE(_T("An error has occurred on a watched directory!\n"));
+ TRACE(_T("This directory has become unwatched! -- %s \n"), strDirectoryName);
+ TRACE(_T("ReadDirectoryChangesW has failed! %d"), dwError);
+ ASSERT( FALSE );//you should override this function no matter what. an error will occur someday.
+}
+
+void CDirectoryChangeHandler::On_WatchStarted(DWORD dwError, const CString & strDirectoryName)
+{
+ if( dwError == 0 )
+ TRACE(_T("A watch has begun on the following directory: %s\n"), strDirectoryName);
+ else
+ TRACE(_T("A watch failed to start on the following directory: (Error: %d) %s\n"),dwError, strDirectoryName);
+}
+
+void CDirectoryChangeHandler::On_WatchStopped(const CString & strDirectoryName)
+{
+ TRACE(_T("The watch on the following directory has stopped: %s\n"), strDirectoryName);
+}
+
+bool CDirectoryChangeHandler::On_FilterNotification(DWORD /*dwNotifyAction*/, LPCTSTR /*szFileName*/, LPCTSTR /*szNewFileName*/)
+//
+// bool On_FilterNotification(DWORD dwNotifyAction, LPCTSTR szFileName, LPCTSTR szNewFileName);
+//
+// This function gives your class a chance to filter unwanted notifications.
+//
+// PARAMETERS:
+// DWORD dwNotifyAction -- specifies the event to filter
+// LPCTSTR szFileName -- specifies the name of the file for the event.
+// LPCTSTR szNewFileName -- specifies the new file name of a file that has been renamed.
+//
+// RETURN VALUE:
+// return true from this function, and you will receive the notification.
+// return false from this function, and your class will NOT receive the notification.
+//
+// Valid values of dwNotifyAction:
+// FILE_ACTION_ADDED -- On_FileAdded() is about to be called.
+// FILE_ACTION_REMOVED -- On_FileRemoved() is about to be called.
+// FILE_ACTION_MODIFIED -- On_FileModified() is about to be called.
+// FILE_ACTION_RENAMED_OLD_NAME-- On_FileNameChanged() is about to be call.
+//
+//
+// NOTE: When the value of dwNotifyAction is FILE_ACTION_RENAMED_OLD_NAME,
+// szFileName will be the old name of the file, and szNewFileName will
+// be the new name of the renamed file.
+//
+// The default implementation always returns true, indicating that all notifications will
+// be sent.
+//
+{
+ return true;
+}
+
+void CDirectoryChangeHandler::SetChangedDirectoryName(const CString & strChangedDirName)
+{
+ m_strChangedDirectoryName = strChangedDirName;
+}
+////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+
+CDirectoryChangeWatcher::CDirectoryChangeWatcher(bool bAppHasGUI /*= true*/, DWORD dwFilterFlags/*=FILTERS_CHECK_FILE_NAME_ONLY*/)
+: m_hCompPort( NULL )
+ ,m_hThread( NULL )
+ ,m_dwThreadID( 0UL )
+ ,m_bAppHasGUI( bAppHasGUI )
+ ,m_dwFilterFlags( dwFilterFlags == 0? FILTERS_DEFAULT_BEHAVIOR : dwFilterFlags)
+{
+ //NOTE:
+ // The bAppHasGUI variable indicates that you have a message pump associated
+ // with the main thread(or the thread that first calls CDirectoryChangeWatcher::WatchDirectory() ).
+ // Directory change notifications are dispatched to your main thread.
+ //
+ // If your app doesn't have a gui, then pass false. Doing so causes a worker thread
+ // to be created that implements a message pump where it dispatches/executes the notifications.
+ // It's ok to pass false even if your app does have a GUI.
+ // Passing false is required for Console applications, or applications without a message pump.
+ // Note that notifications are fired in a worker thread.
+ //
+
+ //NOTE:
+ //
+ //
+}
+
+CDirectoryChangeWatcher::~CDirectoryChangeWatcher()
+{
+
+ UnwatchAllDirectories();
+
+ if( m_hCompPort )
+ {
+ CloseHandle( m_hCompPort );
+ m_hCompPort = NULL;
+ }
+}
+
+DWORD CDirectoryChangeWatcher::SetFilterFlags(DWORD dwFilterFlags)
+//
+// SetFilterFlags()
+//
+// sets filter behavior for directories watched AFTER this function has been called.
+//
+//
+//
+{
+ DWORD dwOld = m_dwFilterFlags;
+ m_dwFilterFlags = dwFilterFlags;
+ if( m_dwFilterFlags == 0 )
+ m_dwFilterFlags = FILTERS_DEFAULT_BEHAVIOR;//the default.
+ return dwOld;
+}
+
+BOOL CDirectoryChangeWatcher::IsWatchingDirectory(const CString & strDirName)const
+/*********************************************
+ Determines whether or not a directory is being watched
+
+ be carefull that you have the same name path name, including the backslash
+ as was used in the call to WatchDirectory().
+
+ ie:
+ "C:\\Temp"
+ is different than
+ "C:\\Temp\\"
+**********************************************/
+{
+ CSingleLock lock( const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);
+ ASSERT( lock.IsLocked() );
+ int i;
+ if( GetDirWatchInfo(strDirName, i) )
+ return TRUE;
+ return FALSE;
+}
+
+int CDirectoryChangeWatcher::NumWatchedDirectories()const
+{
+ CSingleLock lock(const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);
+ ASSERT( lock.IsLocked() );
+ int nCnt(0),max = m_DirectoriesToWatch.GetSize();
+ for(int i(0); i < max; ++i)
+ {
+ if( m_DirectoriesToWatch[i] != NULL )//array may contain NULL elements.
+ nCnt++;
+ }
+
+ return nCnt;
+}
+
+DWORD CDirectoryChangeWatcher::WatchDirectory(const CString & strDirToWatch,
+ DWORD dwChangesToWatchFor,
+ CDirectoryChangeHandler * pChangeHandler,
+ BOOL bWatchSubDirs /*=FALSE*/,
+ LPCTSTR szIncludeFilter /*=NULL*/,
+ LPCTSTR szExcludeFilter /*=NULL*/
+ )
+/*************************************************************
+FUNCTION: WatchDirectory(const CString & strDirToWatch, --the name of the directory to watch
+ DWORD dwChangesToWatchFor, --the changes to watch for see dsk docs..for ReadDirectoryChangesW
+ CDirectoryChangeHandler * pChangeHandler -- handles changes in specified directory
+ BOOL bWatchSubDirs --specified to watch sub directories of the directory that you want to watch
+ )
+
+PARAMETERS:
+ const CString & strDirToWatch -- specifies the path of the directory to watch.
+ DWORD dwChangesToWatchFor -- specifies flags to be passed to ReadDirectoryChangesW()
+ CDirectoryChangeHandler * -- ptr to an object which will handle notifications of file changes.
+ BOOL bWatchSubDirs -- specifies to watch subdirectories.
+ LPCTSTR szIncludeFilter -- A file pattern string for files that you wish to receive notifications
+ for. See Remarks.
+ LPCTSTR szExcludeFilter -- A file pattern string for files that you do not wish to receive notifications for. See Remarks
+
+ Starts watching the specified directory(and optionally subdirectories) for the specified changes
+
+ When specified changes take place the appropriate CDirectoryChangeHandler::On_Filexxx() function is called.
+
+ dwChangesToWatchFor can be a combination of the following flags, and changes map out to the
+ following functions:
+ FILE_NOTIFY_CHANGE_FILE_NAME -- CDirectoryChangeHandler::On_FileAdded()
+ CDirectoryChangeHandler::On_FileNameChanged,
+ CDirectoryChangeHandler::On_FileRemoved
+ FILE_NOTIFY_CHANGE_DIR_NAME -- CDirectoryChangeHandler::On_FileNameAdded(),
+ CDirectoryChangeHandler::On_FileRemoved
+ FILE_NOTIFY_CHANGE_ATTRIBUTES -- CDirectoryChangeHandler::On_FileModified
+ FILE_NOTIFY_CHANGE_SIZE -- CDirectoryChangeHandler::On_FileModified
+ FILE_NOTIFY_CHANGE_LAST_WRITE -- CDirectoryChangeHandler::On_FileModified
+ FILE_NOTIFY_CHANGE_LAST_ACCESS -- CDirectoryChangeHandler::On_FileModified
+ FILE_NOTIFY_CHANGE_CREATION -- CDirectoryChangeHandler::On_FileModified
+ FILE_NOTIFY_CHANGE_SECURITY -- CDirectoryChangeHandler::On_FileModified?
+
+
+ Returns ERROR_SUCCESS if the directory will be watched,
+ or a windows error code if the directory couldn't be watched.
+ The error code will most likely be related to a call to CreateFile(), or
+ from the initial call to ReadDirectoryChangesW(). It's also possible to get an
+ error code related to being unable to create an io completion port or being unable
+ to start the worker thread.
+
+ This function will fail if the directory to be watched resides on a
+ computer that is not a Windows NT/2000/XP machine.
+
+
+ You can only have one watch specified at a time for any particular directory.
+ Calling this function with the same directory name will cause the directory to be
+ unwatched, and then watched again(w/ the new parameters that have been passed in).
+
+**************************************************************/
+{
+ ASSERT( dwChangesToWatchFor != 0);
+
+ if( strDirToWatch.IsEmpty()
+ || dwChangesToWatchFor == 0
+ || pChangeHandler == NULL )
+ {
+ TRACE(_T("ERROR: You've passed invalid parameters to CDirectoryChangeWatcher::WatchDirectory()\n"));
+ ::SetLastError(ERROR_INVALID_PARAMETER);
+ return ERROR_INVALID_PARAMETER;
+ }
+
+
+ //double check that it's really a directory
+ if( !IsDirectory( strDirToWatch ) )
+ {
+ TRACE(_T("ERROR: CDirectoryChangeWatcher::WatchDirectory() -- %s is not a directory!\n"), strDirToWatch);
+ ::SetLastError(ERROR_BAD_PATHNAME);
+ return ERROR_BAD_PATHNAME;
+ }
+
+ //double check that this directory is not already being watched....
+ //if it is, then unwatch it before restarting it...
+ if( IsWatchingDirectory( strDirToWatch) )
+ {
+ VERIFY(
+ UnwatchDirectory( strDirToWatch )
+ );
+ }
+ //
+ //
+ // Reference this singleton so that privileges for this process are enabled
+ // so that it has required permissions to use the ReadDirectoryChangesW API, etc.
+ //
+ CPrivilegeEnabler::Instance();
+ //
+ //open the directory to watch....
+ HANDLE hDir = CreateFile(strDirToWatch,
+ FILE_LIST_DIRECTORY,
+ FILE_SHARE_READ | FILE_SHARE_WRITE ,//| FILE_SHARE_DELETE, <-- removing FILE_SHARE_DELETE prevents the user or someone else from renaming or deleting the watched directory. This is a good thing to prevent.
+ NULL, //security attributes
+ OPEN_EXISTING,
+ FILE_FLAG_BACKUP_SEMANTICS | //<- the required priviliges for this flag are: SE_BACKUP_NAME and SE_RESTORE_NAME. CPrivilegeEnabler takes care of that.
+ FILE_FLAG_OVERLAPPED, //OVERLAPPED!
+ NULL);
+ if( hDir == INVALID_HANDLE_VALUE )
+ {
+ DWORD dwError = GetLastError();
+ TRACE(_T("CDirectoryChangeWatcher::WatchDirectory() -- Couldn't open directory for monitoring. %d\n"), dwError);
+ ::SetLastError(dwError);//who knows if TRACE will cause GetLastError() to return success...probably won't, but set it manually just for fun.
+ return dwError;
+ }
+ //opened the dir!
+
+ CDirWatchInfo * pDirInfo = new CDirWatchInfo( hDir, strDirToWatch, pChangeHandler, dwChangesToWatchFor, bWatchSubDirs, m_bAppHasGUI, szIncludeFilter, szExcludeFilter, m_dwFilterFlags);
+ if( !pDirInfo )
+ {
+ TRACE(_T("WARNING: Couldn't allocate a new CDirWatchInfo() object --- File: %s Line: %d\n"), _T( __FILE__ ), __LINE__);
+ CloseHandle( hDir );
+ ::SetLastError(ERROR_OUTOFMEMORY);
+ return ERROR_OUTOFMEMORY;
+ }
+
+ //create a IO completion port/or associate this key with
+ //the existing IO completion port
+ m_hCompPort = CreateIoCompletionPort(hDir,
+ m_hCompPort, //if m_hCompPort is NULL, hDir is associated with a NEW completion port,
+ //if m_hCompPort is NON-NULL, hDir is associated with the existing completion port that the handle m_hCompPort references
+ (DWORD)pDirInfo, //the completion 'key'... this ptr is returned from GetQueuedCompletionStatus() when one of the events in the dwChangesToWatchFor filter takes place
+ 0);
+ if( m_hCompPort == NULL )
+ {
+ TRACE(_T("ERROR -- Unable to create I/O Completion port! GetLastError(): %d File: %s Line: %d"), GetLastError(), _T( __FILE__ ), __LINE__ );
+ DWORD dwError = GetLastError();
+ pDirInfo->DeleteSelf( NULL );
+ ::SetLastError(dwError);//who knows what the last error will be after i call pDirInfo->DeleteSelf(), so set it just to make sure
+ return dwError;
+ }
+ else
+ {//completion port created/directory associated w/ it successfully
+
+ //if the thread isn't running start it....
+ //when the thread starts, it will call ReadDirectoryChangesW and wait
+ //for changes to take place
+ if( m_hThread == NULL )
+ {
+ //start the thread
+ CWinThread * pThread = AfxBeginThread(MonitorDirectoryChanges, this);
+ if( !pThread )
+ {//couldn't create the thread!
+ TRACE(_T("CDirectoryChangeWatcher::WatchDirectory()-- AfxBeginThread failed!\n"));
+ pDirInfo->DeleteSelf( NULL );
+ return (GetLastError() == ERROR_SUCCESS)? ERROR_MAX_THRDS_REACHED : GetLastError();
+ }
+ else
+ {
+ m_hThread = pThread->m_hThread;
+ m_dwThreadID = pThread->m_nThreadID;
+ pThread->m_bAutoDelete = TRUE;//pThread is deleted when thread ends....it's TRUE by default(for CWinThread ptrs returned by AfxBeginThread(threadproc, void*)), but just makin sure.
+
+ }
+ }
+ if( m_hThread != NULL )
+ {//thread is running,
+ //signal the thread to issue the initial call to
+ //ReadDirectoryChangesW()
+ DWORD dwStarted = pDirInfo->StartMonitor( m_hCompPort );
+
+ if( dwStarted != ERROR_SUCCESS )
+ {//there was a problem!
+ TRACE(_T("Unable to watch directory: %s -- GetLastError(): %d\n"), dwStarted);
+ pDirInfo->DeleteSelf( NULL );
+ ::SetLastError(dwStarted);//I think this'll set the Err object in a VB app.....
+ return dwStarted;
+ }
+ else
+ {//ReadDirectoryChangesW was successfull!
+ //add the directory info to the first empty slot in the array
+
+ //associate the pChangeHandler with this object
+ pChangeHandler->ReferencesWatcher( this );//reference is removed when directory is unwatched.
+ //CDirWatchInfo::DeleteSelf() must now be called w/ this CDirectoryChangeWatcher pointer becuse
+ //of a reference count
+
+ //save the CDirWatchInfo* so I'll be able to use it later.
+ VERIFY( AddToWatchInfo( pDirInfo ) );
+ SetLastError(dwStarted);
+ return dwStarted;
+ }
+
+ }
+ else
+ {
+ ASSERT(FALSE);//control path shouldn't get here
+ ::SetLastError(ERROR_MAX_THRDS_REACHED);
+ return ERROR_MAX_THRDS_REACHED;
+ }
+
+ }
+ ASSERT( FALSE );//shouldn't get here.
+}
+
+BOOL CDirectoryChangeWatcher::UnwatchAllDirectories()
+{
+
+ //unwatch all of the watched directories
+ //delete all of the CDirWatchInfo objects,
+ //kill off the worker thread
+ if( m_hThread != NULL )
+ {
+ ASSERT( m_hCompPort != NULL );
+
+ CSingleLock lock( &m_csDirWatchInfo, TRUE);
+ ASSERT( lock.IsLocked() );
+
+ CDirWatchInfo * pDirInfo;
+ //Unwatch each of the watched directories
+ //and delete the CDirWatchInfo associated w/ that directory...
+ int max = m_DirectoriesToWatch.GetSize();
+ for(int i = 0; i < max; ++i)
+ {
+ if( (pDirInfo = m_DirectoriesToWatch[i]) != NULL )
+ {
+ VERIFY( pDirInfo->UnwatchDirectory( m_hCompPort ) );
+
+ m_DirectoriesToWatch.SetAt(i, NULL) ;
+ pDirInfo->DeleteSelf(this);
+ }
+
+ }
+ m_DirectoriesToWatch.RemoveAll();
+ //kill off the thread
+ PostQueuedCompletionStatus(m_hCompPort, 0, 0, NULL);//The thread will catch this and exit the thread
+ //wait for it to exit
+ WaitForSingleObject(m_hThread, INFINITE);
+ //CloseHandle( m_hThread );//Since thread was started w/ AfxBeginThread() this handle is closed automatically, closing it again will raise an exception
+ m_hThread = NULL;
+ m_dwThreadID = 0UL;
+
+ //close the completion port...
+ CloseHandle( m_hCompPort );
+ m_hCompPort = NULL;
+
+
+ return TRUE;
+ }
+ else
+ {
+#ifdef _DEBUG
+ //make sure that there aren't any
+ //CDirWatchInfo objects laying around... they should have all been destroyed
+ //and removed from the array m_DirectoriesToWatch
+ if( m_DirectoriesToWatch.GetSize() > 0 )
+ {
+ for(int i = 0; i < m_DirectoriesToWatch.GetSize(); ++i)
+ {
+ ASSERT( m_DirectoriesToWatch[i] == NULL );
+ }
+ }
+#endif
+ }
+ return FALSE;
+}
+
+BOOL CDirectoryChangeWatcher::UnwatchDirectory(const CString & strDirToStopWatching)
+/***************************************************************
+FUNCTION: UnwatchDirectory(const CString & strDirToStopWatching -- if this directory is being watched, the watch is stopped
+
+****************************************************************/
+{
+ BOOL bRetVal = FALSE;
+
+
+
+ if( m_hCompPort != NULL )//The io completion port must be open
+ {
+ ASSERT( !strDirToStopWatching.IsEmpty() );
+
+ CSingleLock lock(&m_csDirWatchInfo, TRUE);
+ ASSERT( lock.IsLocked() );
+ int nIdx = -1;
+ CDirWatchInfo * pDirInfo = GetDirWatchInfo(strDirToStopWatching, nIdx);
+ if( pDirInfo != NULL
+ && nIdx != -1 )
+ {
+
+ //stop watching this directory
+ VERIFY( pDirInfo->UnwatchDirectory( m_hCompPort ) );
+
+ //cleanup the object used to watch the directory
+ m_DirectoriesToWatch.SetAt(nIdx, NULL);
+ pDirInfo->DeleteSelf(this);
+ bRetVal = TRUE;
+ }
+ }
+
+ return bRetVal;
+}
+
+BOOL CDirectoryChangeWatcher::UnwatchDirectory(CDirectoryChangeHandler * pChangeHandler)
+/************************************
+
+ This function is called from the dtor of CDirectoryChangeHandler automatically,
+ but may also be called by a programmer because it's public...
+
+ A single CDirectoryChangeHandler may be used for any number of watched directories.
+
+ Unwatch any directories that may be using this
+ CDirectoryChangeHandler * pChangeHandler to handle changes to a watched directory...
+
+ The CDirWatchInfo::m_pChangeHandler member of objects in the m_DirectoriesToWatch
+ array will == pChangeHandler if that handler is being used to handle changes to a directory....
+************************************/
+{
+ ASSERT( pChangeHandler );
+
+ CSingleLock lock(&m_csDirWatchInfo, TRUE);
+
+ ASSERT( lock.IsLocked() );
+
+ int nUnwatched = 0;
+ int nIdx = -1;
+ CDirWatchInfo * pDirInfo;
+ //
+ // go through and unwatch any directory that is
+ // that is using this pChangeHandler as it's file change notification handler.
+ //
+ while( (pDirInfo = GetDirWatchInfo( pChangeHandler, nIdx )) != NULL )
+ {
+ VERIFY( pDirInfo->UnwatchDirectory( m_hCompPort ) );
+
+ nUnwatched++;
+ m_DirectoriesToWatch.SetAt(nIdx, NULL);
+ pDirInfo->DeleteSelf(this);
+ }
+ return (BOOL)(nUnwatched != 0);
+}
+
+BOOL CDirectoryChangeWatcher::UnwatchDirectoryBecauseOfError(CDirWatchInfo * pWatchInfo)
+//
+// Called in the worker thread in the case that ReadDirectoryChangesW() fails
+// during normal operation. One way to force this to happen is to watch a folder
+// using a UNC path and changing that computer's IP address.
+//
+{
+ ASSERT( pWatchInfo );
+ ASSERT( m_dwThreadID == GetCurrentThreadId() );//this should be called from the worker thread only.
+ BOOL bRetVal = FALSE;
+ if( pWatchInfo )
+ {
+ CSingleLock lock(&m_csDirWatchInfo, TRUE);
+
+ ASSERT( lock.IsLocked() );
+ int nIdx = -1;
+ if( GetDirWatchInfo(pWatchInfo, nIdx) == pWatchInfo )
+ {
+ // we are actually watching this....
+
+ //
+ // Remove this CDirWatchInfo object from the list of watched directories.
+ //
+ m_DirectoriesToWatch.SetAt(nIdx, NULL);//mark the space as free for the next watch...
+
+ //
+ // and delete it...
+ //
+
+ pWatchInfo->DeleteSelf(this);
+
+ }
+
+ }
+ return bRetVal;
+}
+
+int CDirectoryChangeWatcher::AddToWatchInfo(CDirectoryChangeWatcher::CDirWatchInfo * pWatchInfo)
+//
+//
+// To add the CDirWatchInfo * to an array.
+// The array is used to keep track of which directories
+// are being watched.
+//
+// Add the ptr to the first non-null slot in the array.
+{
+ CSingleLock lock( &m_csDirWatchInfo, TRUE);
+ ASSERT( lock.IsLocked() );
+
+ //first try to add it to the first empty slot in m_DirectoriesToWatch
+ int max = m_DirectoriesToWatch.GetSize();
+ for(int i = 0; i < max; ++i)
+ {
+ if( m_DirectoriesToWatch[i] == NULL )
+ {
+ m_DirectoriesToWatch[i] = pWatchInfo;
+ break;
+ }
+ }
+ if( i == max )
+ {
+ // there where no empty slots, add it to the end of the array
+ try{
+ i = m_DirectoriesToWatch.Add( pWatchInfo );
+ }
+ catch(CMemoryException * e){
+ e->ReportError();
+ e->Delete();//??? delete this? I thought CMemoryException objects where pre allocated in mfc? -- sample code in msdn does, so will i
+ i = -1;
+ }
+ }
+
+ return (BOOL)(i != -1);
+}
+
+//
+// functions for retrieving the directory watch info based on different parameters
+//
+CDirectoryChangeWatcher::CDirWatchInfo * CDirectoryChangeWatcher::GetDirWatchInfo(const CString & strDirName, int & ref_nIdx)const
+{
+ if( strDirName.IsEmpty() )// can't be watching a directory if it's you don't pass in the name of it...
+ return FALSE; //
+
+ CSingleLock lock(const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);
+
+ int max = m_DirectoriesToWatch.GetSize();
+ CDirWatchInfo * p = NULL;
+ for(int i = 0; i < max; ++i )
+ {
+ if( (p = m_DirectoriesToWatch[i]) != NULL
+ && p->m_strDirName.CompareNoCase( strDirName ) == 0 )
+ {
+ ref_nIdx = i;
+ return p;
+ }
+ }
+
+ return NULL;//NOT FOUND
+}
+
+CDirectoryChangeWatcher::CDirWatchInfo * CDirectoryChangeWatcher::GetDirWatchInfo(CDirectoryChangeWatcher::CDirWatchInfo * pWatchInfo, int & ref_nIdx)const
+{
+ ASSERT( pWatchInfo != NULL );
+
+ CSingleLock lock( const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);
+ int i(0), max = m_DirectoriesToWatch.GetSize();
+ CDirWatchInfo * p;
+ for(; i < max; ++i)
+ {
+ if( (p = m_DirectoriesToWatch[i]) != NULL
+ && p == pWatchInfo )
+ {
+ ref_nIdx = i;
+ return p;
+ }
+ }
+ return NULL;//NOT FOUND
+}
+
+CDirectoryChangeWatcher::CDirWatchInfo * CDirectoryChangeWatcher::GetDirWatchInfo(CDirectoryChangeHandler * pChangeHandler, int & ref_nIdx)const
+{
+ ASSERT( pChangeHandler != NULL );
+ CSingleLock lock( const_cast<CCriticalSection*>(&m_csDirWatchInfo), TRUE);
+ int i(0),max = m_DirectoriesToWatch.GetSize();
+ CDirWatchInfo * p;
+ for( ; i < max; ++i)
+ {
+ if( (p = m_DirectoriesToWatch[i]) != NULL
+ && p->GetRealChangeHandler() == pChangeHandler )
+ {
+ ref_nIdx = i;
+ return p;
+ }
+ }
+ return NULL;//NOT FOUND
+}
+
+long CDirectoryChangeWatcher::ReleaseReferenceToWatcher(CDirectoryChangeHandler * pChangeHandler)
+{
+ ASSERT( pChangeHandler );
+ return pChangeHandler->ReleaseReferenceToWatcher(this);
+}
+
+CDirectoryChangeWatcher::CDirWatchInfo::CDirWatchInfo(HANDLE hDir,
+ const CString & strDirectoryName,
+ CDirectoryChangeHandler * pChangeHandler,
+ DWORD dwChangeFilter,
+ BOOL bWatchSubDir,
+ bool bAppHasGUI,
+ LPCTSTR szIncludeFilter,
+ LPCTSTR szExcludeFilter,
+ DWORD dwFilterFlags)
+ : m_pChangeHandler( NULL ),
+ m_hDir(hDir),
+ m_dwChangeFilter( dwChangeFilter ),
+ m_bWatchSubDir( bWatchSubDir ),
+ m_strDirName( strDirectoryName ),
+ m_dwBufLength(0),
+ m_dwReadDirError(ERROR_SUCCESS),
+ m_StartStopEvent(FALSE, TRUE), //NOT SIGNALLED, MANUAL RESET
+ m_RunningState( RUNNING_STATE_NOT_SET )
+{
+
+ ASSERT( hDir != INVALID_HANDLE_VALUE
+ && !strDirectoryName.IsEmpty() );
+
+ //
+ // This object 'decorates' the pChangeHandler passed in
+ // so that notifications fire in the context a thread other than
+ // CDirectoryChangeWatcher::MonitorDirectoryChanges()
+ //
+ // Supports the include and exclude filters
+ //
+ //
+ m_pChangeHandler = new CDelayedDirectoryChangeHandler( pChangeHandler, bAppHasGUI, szIncludeFilter, szExcludeFilter, dwFilterFlags );
+ if( m_pChangeHandler )
+ m_pChangeHandler->SetPartialPathOffset( m_strDirName );//to support FILTERS_CHECK_PARTIAL_PATH..this won't change for the duration of the watch, so set it once... HERE!
+ ASSERT( m_pChangeHandler );
+
+ ASSERT( GetChangeHandler() );
+ ASSERT( GetRealChangeHandler() );
+ if( GetRealChangeHandler() )
+ GetRealChangeHandler()->AddRef();
+
+ memset(&m_Overlapped, 0, sizeof(m_Overlapped));
+ //memset(m_Buffer, 0, sizeof(m_Buffer));
+}
+
+CDirectoryChangeWatcher::CDirWatchInfo::~CDirWatchInfo()
+{
+ if( GetChangeHandler() )
+ {//If this call to CDirectoryChangeHandler::Release() causes m_pChangeHandler to delete itself,
+ //the dtor for CDirectoryChangeHandler will call CDirectoryChangeWatcher::UnwatchDirectory( CDirectoryChangeHandler * ),
+ //which will make try to delete this object again.
+ //if m_pChangeHandler is NULL, it won't try to delete this object again...
+ CDirectoryChangeHandler * pTmp = SetRealDirectoryChangeHandler( NULL );
+ if( pTmp )
+ pTmp->Release();
+ else{
+ ASSERT( FALSE );
+ }
+ }
+
+ CloseDirectoryHandle();
+
+ delete m_pChangeHandler;
+ m_pChangeHandler = NULL;
+
+}
+void CDirectoryChangeWatcher::CDirWatchInfo::DeleteSelf(CDirectoryChangeWatcher * pWatcher)
+//
+// There's a reason for this function!
+//
+// the dtor is private to enforce that it is used.
+//
+//
+// pWatcher can be NULL only if CDirecotryChangeHandler::ReferencesWatcher() has NOT been called.
+// ie: in certain sections of WatchDirectory() it's ok to pass this w/ NULL, but no where else.
+//
+{
+ //ASSERT( pWatcher != NULL );
+
+
+ ASSERT( GetRealChangeHandler() );
+ if( pWatcher )
+ {
+ //
+ //
+ // Before this object is deleted, the CDirectoryChangeHandler object
+ // needs to release it's reference count to the CDirectoryChangeWatcher object.
+ // I might forget to do this since I getting rid of CDirWatchInfo objects
+ // in more than one place...hence the reason for this function.
+ //
+ pWatcher->ReleaseReferenceToWatcher( GetRealChangeHandler() );
+ }
+
+ delete this;
+}
+
+CDelayedDirectoryChangeHandler* CDirectoryChangeWatcher::CDirWatchInfo::GetChangeHandler() const
+{
+ return m_pChangeHandler;
+}
+
+CDirectoryChangeHandler * CDirectoryChangeWatcher::CDirWatchInfo::GetRealChangeHandler() const
+//
+// The 'real' change handler is the CDirectoryChangeHandler object
+// passed to CDirectoryChangeWatcher::WatchDirectory() -- this is the object
+// that really handles the changes.
+//
+{
+ ASSERT( m_pChangeHandler );
+ return m_pChangeHandler->GetRealChangeHandler();
+}
+
+CDirectoryChangeHandler * CDirectoryChangeWatcher::CDirWatchInfo::SetRealDirectoryChangeHandler(CDirectoryChangeHandler * pChangeHandler)
+//
+// Allows you to switch out, at run time, which object really handles the change notifications.
+//
+{
+ CDirectoryChangeHandler * pOld = GetRealChangeHandler();
+ m_pChangeHandler->GetRealChangeHandler() = pChangeHandler;
+ return pOld;
+}
+
+BOOL CDirectoryChangeWatcher::CDirWatchInfo::CloseDirectoryHandle()
+//
+// Closes the directory handle that was opened in CDirectoryChangeWatcher::WatchDirecotry()
+//
+//
+{
+ BOOL b = TRUE;
+ if( m_hDir != INVALID_HANDLE_VALUE )
+ {
+ b = CloseHandle(m_hDir);
+ m_hDir = INVALID_HANDLE_VALUE;
+ }
+ return b;
+}
+
+DWORD CDirectoryChangeWatcher::CDirWatchInfo::StartMonitor(HANDLE hCompPort)
+/*********************************************
+ Sets the running state of the object to perform the initial call to ReadDirectoryChangesW()
+ , wakes up the thread waiting on GetQueuedCompletionStatus()
+ and waits for an event to be set before returning....
+
+ The return value is either ERROR_SUCCESS if ReadDirectoryChangesW is successfull,
+ or is the value of GetLastError() for when ReadDirectoryChangesW() failed.
+**********************************************/
+{
+ ASSERT( hCompPort );
+
+ //Guard the properties of this object
+ VERIFY( LockProperties() );
+
+
+
+ m_RunningState = RUNNING_STATE_START_MONITORING;//set the state member to indicate that the object is to START monitoring the specified directory
+ PostQueuedCompletionStatus(hCompPort, sizeof(this), (DWORD)this, &m_Overlapped);//make the thread waiting on GetQueuedCompletionStatus() wake up
+
+ VERIFY( UnlockProperties() );//unlock this object so that the thread can get at them...
+
+ //wait for signal that the initial call
+ //to ReadDirectoryChanges has been made
+ DWORD dwWait = 0;
+ do{
+ dwWait = WaitForSingleObject(m_StartStopEvent, 10 * 1000);
+ if( dwWait != WAIT_OBJECT_0 )
+ {
+ //
+ // shouldn't ever see this one....but just in case you do, notify me of the problem wesj@hotmail.com.
+ //
+ TRACE(_T("WARNING! Possible lockup detected. FILE: %s Line: %d\n"), _T( __FILE__ ), __LINE__);
+ }
+ } while( dwWait != WAIT_OBJECT_0 );
+
+ ASSERT( dwWait == WAIT_OBJECT_0 );
+ m_StartStopEvent.ResetEvent();
+
+ return m_dwReadDirError;//This value is set in the worker thread when it first calls ReadDirectoryChangesW().
+}
+
+BOOL CDirectoryChangeWatcher::CDirWatchInfo::UnwatchDirectory(HANDLE hCompPort)
+/*******************************************
+
+ Sets the running state of the object to stop monitoring a directory,
+ Causes the worker thread to wake up and to stop monitoring the dierctory
+
+********************************************/
+{
+ ASSERT( hCompPort );
+ //
+ // Signal that the worker thread is to stop watching the directory
+ //
+ if( SignalShutdown(hCompPort) )
+ {
+ //and wait for the thread to signal that it has shutdown
+ return WaitForShutdown();
+
+ }
+ return FALSE;
+}
+
+BOOL CDirectoryChangeWatcher::CDirWatchInfo::SignalShutdown( HANDLE hCompPort )
+//added to fix a bug -- this will be called normally by UnwatchDirectory(HANDLE)
+// and abnormally by the worker thread in the case that ReadDirectoryChangesW fails -- see code.
+//
+// Signals the worker thread(via the I/O completion port) that it is to stop watching the
+// directory for this object, and then returns.
+//
+{
+ BOOL bRetVal = FALSE;
+ ASSERT( hCompPort );
+ ASSERT( m_hDir != INVALID_HANDLE_VALUE );
+ //Lock the properties so that they aren't modified by another thread
+ VERIFY( LockProperties() ); //unlikey to fail...
+
+ //set the state member to indicate that the object is to stop monitoring the
+ //directory that this CDirWatchInfo is responsible for...
+ m_RunningState = CDirectoryChangeWatcher::CDirWatchInfo::RUNNING_STATE_STOP;
+ //put this object in the I/O completion port... GetQueuedCompletionStatus() will return it inside the worker thread.
+ bRetVal = PostQueuedCompletionStatus(hCompPort, sizeof(CDirWatchInfo*), (DWORD)this, &m_Overlapped);
+
+ if( !bRetVal )
+ {
+ TRACE(_T("PostQueuedCompletionStatus() failed! GetLastError(): %d\n"), GetLastError());
+ }
+ VERIFY( UnlockProperties() );
+
+ return bRetVal;
+}
+
+BOOL CDirectoryChangeWatcher::CDirWatchInfo::WaitForShutdown()
+//
+// This is to be called some time after SignalShutdown().
+//
+//
+{
+ ASSERT_VALID(&m_StartStopEvent);
+
+ //Wait for the Worker thread to indicate that the watch has been stopped
+ DWORD dwWait;
+ bool bWMQuitReceived = false;
+ do{
+ dwWait = MsgWaitForMultipleObjects(1, &m_StartStopEvent.m_hObject, FALSE, 5000, QS_ALLINPUT);//wait five seconds
+ switch( dwWait )
+ {
+ case WAIT_OBJECT_0:
+ //handle became signalled!
+ break;
+ case WAIT_OBJECT_0 + 1:
+ {
+ //This thread awoke due to sent/posted message
+ //process the message Q
+ //
+ // There is a message in this thread's queue, so
+ // MsgWaitForMultipleObjects returned.
+ // Process those messages, and wait again.
+
+ MSG msg;
+ while( PeekMessage(&msg, NULL, 0,0, PM_REMOVE ) )
+ {
+ if( msg.message != WM_QUIT)
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ else
+ {
+ /****
+ This appears to be causing quite a lot of pain, to quote Mustafa.
+
+ //it's the WM_QUIT message, put it back in the Q and
+ // exit this function
+ PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam );
+ bWMQuitReceived = true;
+
+ ****/
+ break;
+ }
+ }
+ }break;
+ case WAIT_TIMEOUT:
+ {
+ TRACE(_T("WARNING: Possible Deadlock detected! ThreadID: %d File: %s Line: %d\n"), GetCurrentThreadId(), _T(__FILE__), __LINE__);
+ }break;
+ }//end switch(dwWait)
+ }while( dwWait != WAIT_OBJECT_0 && !bWMQuitReceived );
+
+
+
+ ASSERT( dwWait == WAIT_OBJECT_0 || bWMQuitReceived);
+
+ m_StartStopEvent.ResetEvent();
+
+ return (BOOL) (dwWait == WAIT_OBJECT_0 || bWMQuitReceived);
+}
+
+
+UINT CDirectoryChangeWatcher::MonitorDirectoryChanges(LPVOID lpvThis)
+/********************************************
+ The worker thread function which monitors directory changes....
+********************************************/
+{
+ DWORD numBytes;
+
+ CDirWatchInfo * pdi;
+ LPOVERLAPPED lpOverlapped;
+
+ CDirectoryChangeWatcher * pThis = reinterpret_cast<CDirectoryChangeWatcher*>(lpvThis);
+ ASSERT( pThis );
+
+ pThis->On_ThreadInitialize();
+
+
+ do
+ {
+ // Retrieve the directory info for this directory
+ // through the io port's completion key
+ if( !GetQueuedCompletionStatus( pThis->m_hCompPort,
+ &numBytes,
+ (LPDWORD) &pdi,//<-- completion Key
+ &lpOverlapped,
+ INFINITE) )
+ {//The io completion request failed...
+ //probably because the handle to the directory that
+ //was used in a call to ReadDirectoryChangesW has been closed.
+
+ //
+ // calling pdi->CloseDirectoryHandle() will cause GetQueuedCompletionStatus() to return false.
+ //
+ //
+ if( !pdi
+ || ( pdi && AfxIsValidAddress(pdi, sizeof(CDirectoryChangeWatcher::CDirWatchInfo)))
+ && pdi->m_hDir != INVALID_HANDLE_VALUE //the directory handle is still open! (we expect this when after we close the directory handle )
+ )
+ {
+#ifdef _DEBUG
+ TRACE(_T("GetQueuedCompletionStatus() returned FALSE\nGetLastError(): %d Completion Key: %p lpOverlapped: %p\n"), GetLastError(), pdi, lpOverlapped);
+ MessageBeep( static_cast<UINT>(-1) );
+#endif
+ }
+ }
+
+ if ( pdi )//pdi will be null if I call PostQueuedCompletionStatus(m_hCompPort, 0,0,NULL);
+ {
+ //
+ // The following check to AfxIsValidAddress() should go off in the case
+ // that I have deleted this CDirWatchInfo object, but it was still in
+ // "in the Queue" of the i/o completion port from a previous overlapped operation.
+ //
+ ASSERT( AfxIsValidAddress(pdi,
+ sizeof(CDirectoryChangeWatcher::CDirWatchInfo)) );
+ /***********************************
+ The CDirWatchInfo::m_RunningState is pretty much the only member
+ of CDirWatchInfo that can be modified from the other thread.
+ The functions StartMonitor() and UnwatchDirecotry() are the functions that
+ can modify that variable.
+
+ So that I'm sure that I'm getting the right value,
+ I'm using a critical section to guard against another thread modyfying it when I want
+ to read it...
+
+ ************************************/
+ bool bObjectShouldBeOk = true;
+ try{
+ VERIFY( pdi->LockProperties() );//don't give the main thread a chance to change this object
+ }
+ catch(...){
+ //any sort of exception here indicates I've
+ //got a hosed object.
+ TRACE(_T("CDirectoryChangeWatcher::MonitorDirectoryChanges() -- pdi->LockProperties() raised an exception!\n"));
+ bObjectShouldBeOk = false;
+ }
+ if( bObjectShouldBeOk )
+ {
+ //while we're working with this object...
+
+ CDirWatchInfo::eRunningState Run_State = pdi->m_RunningState ;
+
+ VERIFY( pdi->UnlockProperties() );//let another thread back at the properties...
+ /***********************************
+ Unlock it so that there isn't a DEADLOCK if
+ somebody tries to call a function which will
+ cause CDirWatchInfo::UnwatchDirectory() to be called
+ from within the context of this thread (eg: a function called because of
+ the handler for one of the CDirectoryChangeHandler::On_Filexxx() functions)
+
+ ************************************/
+
+ ASSERT( pdi->GetChangeHandler() );
+ switch( Run_State )
+ {
+ case CDirWatchInfo::RUNNING_STATE_START_MONITORING:
+ {
+ //Issue the initial call to ReadDirectoryChangesW()
+
+ if( !ReadDirectoryChangesW( pdi->m_hDir,
+ pdi->m_Buffer,//<--FILE_NOTIFY_INFORMATION records are put into this buffer
+ READ_DIR_CHANGE_BUFFER_SIZE,
+ pdi->m_bWatchSubDir,
+ pdi->m_dwChangeFilter,
+ &pdi->m_dwBufLength,//this var not set when using asynchronous mechanisms...
+ &pdi->m_Overlapped,
+ NULL) )//no completion routine!
+ {
+ pdi->m_dwReadDirError = GetLastError();
+ if( pdi->GetChangeHandler() )
+ pdi->GetChangeHandler()->On_WatchStarted(pdi->m_dwReadDirError, pdi->m_strDirName);
+ }
+ else
+ {//read directory changes was successful!
+ //allow it to run normally
+ pdi->m_RunningState = CDirWatchInfo::RUNNING_STATE_NORMAL;
+ pdi->m_dwReadDirError = ERROR_SUCCESS;
+ if( pdi->GetChangeHandler() )
+ pdi->GetChangeHandler()->On_WatchStarted(ERROR_SUCCESS, pdi->m_strDirName );
+ }
+ pdi->m_StartStopEvent.SetEvent();//signall that the ReadDirectoryChangesW has been called
+ //check CDirWatchInfo::m_dwReadDirError to see whether or not ReadDirectoryChangesW succeeded...
+
+ //
+ // note that pdi->m_dwReadDirError is the value returned by WatchDirectory()
+ //
+
+
+ }break;
+ case CDirWatchInfo::RUNNING_STATE_STOP:
+ {
+ //We want to shut down the monitoring of the directory
+ //that pdi is managing...
+
+ if( pdi->m_hDir != INVALID_HANDLE_VALUE )
+ {
+ //Since I've previously called ReadDirectoryChangesW() asynchronously, I am waiting
+ //for it to return via GetQueuedCompletionStatus(). When I close the
+ //handle that ReadDirectoryChangesW() is waiting on, it will
+ //cause GetQueuedCompletionStatus() to return again with this pdi object....
+ // Close the handle, and then wait for the call to GetQueuedCompletionStatus()
+ //to return again by breaking out of the switch, and letting GetQueuedCompletionStatus()
+ //get called again
+ pdi->CloseDirectoryHandle();
+ pdi->m_RunningState = CDirWatchInfo::RUNNING_STATE_STOP_STEP2;//back up step...GetQueuedCompletionStatus() will still need to return from the last time that ReadDirectoryChangesW() was called.....
+
+ //
+ // The watch has been stopped, tell the client about it
+ // if( pdi->GetChangeHandler() )
+ pdi->GetChangeHandler()->On_WatchStopped( pdi->m_strDirName );
+ }
+ else
+ {
+ //either we weren't watching this direcotry in the first place,
+ //or we've already stopped monitoring it....
+ pdi->m_StartStopEvent.SetEvent();//set the event that ReadDirectoryChangesW has returned and no further calls to it will be made...
+ }
+
+
+ }break;
+ case CDirWatchInfo::RUNNING_STATE_STOP_STEP2:
+ {
+
+ //GetQueuedCompletionStatus() has returned from the last
+ //time that ReadDirectoryChangesW was called...
+ //Using CloseHandle() on the directory handle used by
+ //ReadDirectoryChangesW will cause it to return via GetQueuedCompletionStatus()....
+ if( pdi->m_hDir == INVALID_HANDLE_VALUE )
+ pdi->m_StartStopEvent.SetEvent();//signal that no further calls to ReadDirectoryChangesW will be made
+ //and this pdi can be deleted
+ else
+ {//for some reason, the handle is still open..
+
+ pdi->CloseDirectoryHandle();
+
+ //wait for GetQueuedCompletionStatus() to return this pdi object again
+
+
+ }
+
+ }break;
+
+ case CDirWatchInfo::RUNNING_STATE_NORMAL:
+ {
+
+ if( pdi->GetChangeHandler() )
+ pdi->GetChangeHandler()->SetChangedDirectoryName( pdi->m_strDirName );
+
+ DWORD dwReadBuffer_Offset = 0UL;
+
+ //process the FILE_NOTIFY_INFORMATION records:
+ CFileNotifyInformation notify_info( (LPBYTE)pdi->m_Buffer, READ_DIR_CHANGE_BUFFER_SIZE);
+
+ pThis->ProcessChangeNotifications(notify_info, pdi, dwReadBuffer_Offset);
+
+
+ // Changes have been processed,
+ // Reissue the watch command
+ //
+ if( !ReadDirectoryChangesW( pdi->m_hDir,
+ pdi->m_Buffer + dwReadBuffer_Offset,//<--FILE_NOTIFY_INFORMATION records are put into this buffer
+ READ_DIR_CHANGE_BUFFER_SIZE - dwReadBuffer_Offset,
+ pdi->m_bWatchSubDir,
+ pdi->m_dwChangeFilter,
+ &pdi->m_dwBufLength,//this var not set when using asynchronous mechanisms...
+ &pdi->m_Overlapped,
+ NULL) )//no completion routine!
+ {
+ //
+ // NOTE:
+ // In this case the thread will not wake up for
+ // this pdi object because it is no longer associated w/
+ // the I/O completion port...there will be no more outstanding calls to ReadDirectoryChangesW
+ // so I have to skip the normal shutdown routines(normal being what happens when CDirectoryChangeWatcher::UnwatchDirectory() is called.
+ // and close this up, & cause it to be freed.
+ //
+ TRACE(_T("WARNING: ReadDirectoryChangesW has failed during normal operations...failed on directory: %s\n"), pdi->m_strDirName);
+
+ ASSERT( pThis );
+ //
+ // To help insure that this has been unwatched by the time
+ // the main thread processes the On_ReadDirectoryChangesError() notification
+ // bump the thread priority up temporarily. The reason this works is because the notification
+ // is really posted to another thread's message queue,...by setting this thread's priority
+ // to highest, this thread will get to shutdown the watch by the time the other thread has a chance
+ // to handle it. *note* not technically guaranteed 100% to be the case, but in practice it'll work.
+ int nOldThreadPriority = GetThreadPriority( GetCurrentThread() );
+ SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
+
+ //
+ // Notify the client object....(a CDirectoryChangeHandler derived class)
+ //
+ try{
+ pdi->m_dwReadDirError = GetLastError();
+ pdi->GetChangeHandler()->On_ReadDirectoryChangesError( pdi->m_dwReadDirError, pdi->m_strDirName );
+
+
+ //Do the shutdown
+ pThis->UnwatchDirectoryBecauseOfError( pdi );
+ //pdi = NULL; <-- DO NOT set this to NULL, it will cause this worker thread to exit.
+ //pdi is INVALID at this point!!
+ }
+ catch(...)
+ {
+ //just in case of exception, this thread will be set back to
+ //normal priority.
+ }
+ //
+ // Set the thread priority back to normal.
+ //
+ SetThreadPriority(GetCurrentThread(), nOldThreadPriority);
+
+ }
+ else
+ {//success, continue as normal
+ pdi->m_dwReadDirError = ERROR_SUCCESS;
+ }
+ }break;
+ default:
+ TRACE(_T("MonitorDirectoryChanges() -- how did I get here?\n"));
+ break;//how did I get here?
+ }//end switch( pdi->m_RunningState )
+
+
+
+ }//end if( bObjectShouldBeOk )
+ }//end if( pdi )
+ } while( pdi );
+
+ pThis->On_ThreadExit();
+ return 0; //thread is ending
+}
+
+void CDirectoryChangeWatcher::ProcessChangeNotifications(IN CFileNotifyInformation & notify_info,
+ IN CDirectoryChangeWatcher::CDirWatchInfo * pdi,
+ OUT DWORD & ref_dwReadBuffer_Offset//used in case ...see case for FILE_ACTION_RENAMED_OLD_NAME
+ )
+/////////////////////////////////////////////////////////////
+//
+// Processes the change notifications and dispatches the handling of the
+// notifications to the CDirectoryChangeHandler object passed to WatchDirectory()
+//
+/////////////////////////////////////////////////////////////
+{
+ //
+ // Sanity check...
+ // this function should only be called by the worker thread.
+ //
+ ASSERT( m_dwThreadID == GetCurrentThreadId() );
+
+ // Validate parameters...
+ //
+ ASSERT( pdi );
+ ASSERT( AfxIsValidAddress(pdi, sizeof(CDirectoryChangeWatcher::CDirWatchInfo) ) );
+
+ if( !pdi || !AfxIsValidAddress(pdi, sizeof(CDirectoryChangeWatcher::CDirWatchInfo)) )
+ {
+ TRACE(_T("Invalid arguments to CDirectoryChangeWatcher::ProcessChangeNotifications() -- pdi is invalid!\n"));
+ TRACE(_T("File: %s Line: %d"), _T( __FILE__ ), __LINE__ );
+ return;
+ }
+
+
+
+ DWORD dwLastAction = 0;
+ ref_dwReadBuffer_Offset = 0UL;
+
+
+ CDirectoryChangeHandler * pChangeHandler = pdi->GetChangeHandler();
+ //CDelayedDirectoryChangeHandler * pChangeHandler = pdi->GetChangeHandler();
+ ASSERT( pChangeHandler );
+ ASSERT( AfxIsValidAddress(pChangeHandler, sizeof(CDirectoryChangeHandler)) );
+ //ASSERT( AfxIsValidAddress(pChangeHandler, sizeof(CDelayedDirectoryChangeHandler)) );
+ if( !pChangeHandler )
+ {
+ TRACE(_T("CDirectoryChangeWatcher::ProcessChangeNotifications() Unable to continue, pdi->GetChangeHandler() returned NULL!\n"));
+ TRACE(_T("File: %s Line: %d\n"), _T( __FILE__ ), __LINE__ );
+ return;
+ }
+
+
+ //
+ // go through and process the notifications contained in the
+ // CFileChangeNotification object( CFileChangeNotification is a wrapper for the FILE_NOTIFY_INFORMATION structure
+ // returned by ReadDirectoryChangesW)
+ //
+ do
+ {
+ //The FileName member of the FILE_NOTIFY_INFORMATION
+ //structure contains the NAME of the file RELATIVE to the
+ //directory that is being watched...
+ //ie, if watching C:\Temp and the file C:\Temp\MyFile.txt is changed,
+ //the file name will be "MyFile.txt"
+ //If watching C:\Temp, AND you're also watching subdirectories
+ //and the file C:\Temp\OtherFolder\MyOtherFile.txt is modified,
+ //the file name will be "OtherFolder\MyOtherFile.txt
+
+ //The CDirectoryChangeHandler::On_Filexxx() functions will receive the name of the file
+ //which includes the full path to the directory being watched
+
+
+ //
+ // See what the change was
+ //
+
+ switch( notify_info.GetAction() )
+ {
+ case FILE_ACTION_ADDED: // a file was added!
+
+ pChangeHandler->On_FileAdded( notify_info.GetFileNameWithPath( pdi->m_strDirName ) ); break;
+
+ case FILE_ACTION_REMOVED: //a file was removed
+
+ pChangeHandler->On_FileRemoved( notify_info.GetFileNameWithPath( pdi->m_strDirName ) ); break;
+
+ case FILE_ACTION_MODIFIED:
+ //a file was changed
+ //pdi->m_pChangeHandler->On_FileModified( strLastFileName ); break;
+ pChangeHandler->On_FileModified( notify_info.GetFileNameWithPath( pdi->m_strDirName ) ); break;
+
+ case FILE_ACTION_RENAMED_OLD_NAME:
+ {//a file name has changed, and this is the OLD name
+ //This record is followed by another one w/
+ //the action set to FILE_ACTION_RENAMED_NEW_NAME (contains the new name of the file
+
+ CString strOldFileName = notify_info.GetFileNameWithPath( pdi->m_strDirName );
+
+
+ if( notify_info.GetNextNotifyInformation() )
+ {//there is another PFILE_NOTIFY_INFORMATION record following the one we're working on now...
+ //it will be the record for the FILE_ACTION_RENAMED_NEW_NAME record
+
+
+ ASSERT( notify_info.GetAction() == FILE_ACTION_RENAMED_NEW_NAME );//making sure that the next record after the OLD_NAME record is the NEW_NAME record
+
+ //get the new file name
+ CString strNewFileName = notify_info.GetFileNameWithPath( pdi->m_strDirName );
+
+ pChangeHandler->On_FileNameChanged( strOldFileName, strNewFileName);
+ }
+ else
+ {
+ //this OLD_NAME was the last record returned by ReadDirectoryChangesW
+ //I will have to call ReadDirectoryChangesW again so that I will get
+ //the record for FILE_ACTION_RENAMED_NEW_NAME
+
+ //Adjust an offset so that when I call ReadDirectoryChangesW again,
+ //the FILE_NOTIFY_INFORMATION will be placed after
+ //the record that we are currently working on.
+
+ /***************
+ Let's say that 200 files all had their names changed at about the same time
+ There will be 400 FILE_NOTIFY_INFORMATION records (one for OLD_NAME and one for NEW_NAME for EACH file which had it's name changed)
+ that ReadDirectoryChangesW will have to report to
+ me. There might not be enough room in the buffer
+ and the last record that we DID get was an OLD_NAME record,
+ I will need to call ReadDirectoryChangesW again so that I will get the NEW_NAME
+ record. This way I'll always have to strOldFileName and strNewFileName to pass
+ to CDirectoryChangeHandler::On_FileRenamed().
+
+ After ReadDirecotryChangesW has filled out our buffer with
+ FILE_NOTIFY_INFORMATION records,
+ our read buffer would look something like this:
+ End Of Buffer
+ |
+ \-/
+ |_________________________________________________________________________
+ | |
+ |file1 OLD name record|file1 NEW name record|...|fileX+1 OLD_name record| |(the record we want would be here, but we've ran out of room, so we adjust an offset and call ReadDirecotryChangesW again to get it)
+ |_________________________________________________________________________|
+
+ Since the record I need is still waiting to be returned to me,
+ and I need the current 'OLD_NAME' record,
+ I'm copying the current FILE_NOTIFY_INFORMATION record
+ to the beginning of the buffer used by ReadDirectoryChangesW()
+ and I adjust the offset into the read buffer so the the NEW_NAME record
+ will be placed into the buffer after the OLD_NAME record now at the beginning of the buffer.
+
+ Before we call ReadDirecotryChangesW again,
+ modify the buffer to contain the current OLD_NAME record...
+
+ |_______________________________________________________
+ | |
+ |fileX old name record(saved)|<this is now garbage>.....|
+ |_______________________________________________________|
+ /-\
+ |
+ Offset for Read
+ Re-issue the watch command to get the rest of the records...
+
+ ReadDirectoryChangesW(..., pBuffer + (an Offset),
+
+ After GetQueuedCompletionStatus() returns,
+ our buffer will look like this:
+
+ |__________________________________________________________________________________________________________
+ | |
+ |fileX old name record(saved)|fileX new name record(the record we've been waiting for)| <other records>... |
+ |__________________________________________________________________________________________________________|
+
+ Then I'll be able to know that a file name was changed
+ and I will have the OLD and the NEW name of the file to pass to CDirectoryChangeHandler::On_FileNameChanged
+
+ ****************/
+ //NOTE that this case has never happened to me in my testing
+ //so I can only hope that the code works correctly.
+ //It would be a good idea to set a breakpoint on this line of code:
+ VERIFY( notify_info.CopyCurrentRecordToBeginningOfBuffer( ref_dwReadBuffer_Offset ) );
+
+
+ }
+ break;
+ }
+ case FILE_ACTION_RENAMED_NEW_NAME:
+ {
+ //This should have been handled in FILE_ACTION_RENAMED_OLD_NAME
+ ASSERT( dwLastAction == FILE_ACTION_RENAMED_OLD_NAME );
+ ASSERT( FALSE );//this shouldn't get here
+ }
+
+ default:
+ TRACE(_T("CDirectoryChangeWatcher::ProcessChangeNotifications() -- unknown FILE_ACTION_ value! : %d\n"), notify_info.GetAction() );
+ break;//unknown action
+ }
+
+ dwLastAction = notify_info.GetAction();
+
+
+ } while( notify_info.GetNextNotifyInformation() );
+}
\ No newline at end of file |