CDirectoryWatcher Class Reference

#include <CDirectoryWatcher.h>

Collaboration diagram for CDirectoryWatcher:

Public Member Functions
	~CDirectoryWatcher ()
BOOL	IsDead () const
BOOL	RestartWatching ()
void	QuitWatching ()
BOOL	RequestAddWatcher ()
BOOL	RequestTermination ()
void	ReadCompletion (DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered)

Static Public Member Functions
static CDirectoryWatcher *	Create (LPCWSTR pszDirectoryPath, BOOL fSubTree)
static void	RequestAllWatchersTermination ()

Public Attributes
HANDLE	m_hDirectory
WCHAR	m_szDirectoryPath [MAX_PATH]

Protected Member Functions
BOOL	CreateAPCThread ()
void	ProcessNotification ()
	CDirectoryWatcher (LPCWSTR pszDirectoryPath, BOOL fSubTree)

Protected Attributes
BOOL	m_fDead
BOOL	m_fRecursive
CDirectoryList	m_dir_list
OVERLAPPED	m_overlapped

Detailed Description

Definition at line 14 of file CDirectoryWatcher.h.

Constructor & Destructor Documentation

~CDirectoryWatcher()

CDirectoryWatcher::~CDirectoryWatcher

(

)

Definition at line 104 of file CDirectoryWatcher.cpp.

{
    TRACE("CDirectoryWatcher::~CDirectoryWatcher: %p, '%S'\n", this, m_szDirectoryPath);
 
    if (m_hDirectory != INVALID_HANDLE_VALUE)
        CloseHandle(m_hDirectory);
}

CDirectoryWatcher()

CDirectoryWatcher::CDirectoryWatcher ( LPCWSTR  pszDirectoryPath, BOOL  fSubTree  )

protected

Definition at line 71 of file CDirectoryWatcher.cpp.

    : m_fDead(FALSE)
    , m_fRecursive(fSubTree)
    , m_dir_list(pszDirectoryPath, fSubTree)
{
    TRACE("CDirectoryWatcher::CDirectoryWatcher: %p, '%S'\n", this, pszDirectoryPath);
 
    lstrcpynW(m_szDirectoryPath, pszDirectoryPath, MAX_PATH);
 
    // open the directory to watch changes (for ReadDirectoryChangesW)
    m_hDirectory = CreateFileW(pszDirectoryPath, FILE_LIST_DIRECTORY,
                               FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                               NULL, OPEN_EXISTING,
                               FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
                               NULL);
}

Member Function Documentation

Create()

CDirectoryWatcher * CDirectoryWatcher::Create ( LPCWSTR  pszDirectoryPath, BOOL  fSubTree  )

static

Definition at line 89 of file CDirectoryWatcher.cpp.

{
    WCHAR szFullPath[MAX_PATH];
    GetFullPathNameW(pszDirectoryPath, _countof(szFullPath), szFullPath, NULL);
 
    CDirectoryWatcher *pDirectoryWatcher = new CDirectoryWatcher(szFullPath, fSubTree);
    if (pDirectoryWatcher->m_hDirectory == INVALID_HANDLE_VALUE)
    {
        ERR("CreateFileW failed\n");
        delete pDirectoryWatcher;
        pDirectoryWatcher = NULL;
    }
    return pDirectoryWatcher;
}

Referenced by CreateDirectoryWatcherFromRegEntry().

CreateAPCThread()

BOOL CDirectoryWatcher::CreateAPCThread ( )

protected

Definition at line 336 of file CDirectoryWatcher.cpp.

{
    if (s_hThreadAPC != NULL)
        return TRUE;
 
    unsigned tid;
    s_fTerminateAllWatchers = FALSE;
    s_hThreadAPC = (HANDLE)_beginthreadex(NULL, 0, DirectoryWatcherThreadFuncAPC,
                                          NULL, 0, &tid);
    return s_hThreadAPC != NULL;
}

Referenced by RequestAddWatcher().

IsDead()

BOOL CDirectoryWatcher::IsDead

(

)

const

Definition at line 391 of file CDirectoryWatcher.cpp.

{
    return m_fDead;
}

Referenced by ReadCompletion(), and RestartWatching().

ProcessNotification()

void CDirectoryWatcher::ProcessNotification ( )

protected

Definition at line 135 of file CDirectoryWatcher.cpp.

{
    PFILE_NOTIFY_INFORMATION pInfo = (PFILE_NOTIFY_INFORMATION)s_buffer;
    WCHAR szName[MAX_PATH], szPath[MAX_PATH], szTempPath[MAX_PATH];
    DWORD dwEvent, cbName;
    BOOL fDir;
    TRACE("CDirectoryWatcher::ProcessNotification: enter\n");
 
    // for each entry in s_buffer
    szPath[0] = szTempPath[0] = 0;
    for (;;)
    {
        // get name (relative from m_szDirectoryPath)
        cbName = pInfo->FileNameLength;
        if (sizeof(szName) - sizeof(UNICODE_NULL) < cbName)
        {
            ERR("pInfo->FileName is longer than szName\n");
            break;
        }
        // NOTE: FILE_NOTIFY_INFORMATION.FileName is not null-terminated.
        ZeroMemory(szName, sizeof(szName));
        CopyMemory(szName, pInfo->FileName, cbName);
 
        // get full path
        lstrcpynW(szPath, m_szDirectoryPath, _countof(szPath));
        PathAppendW(szPath, szName);
 
        // convert to long pathname if it contains '~'
        if (StrChrW(szPath, L'~') != NULL)
        {
            if (GetLongPathNameW(szPath, szName, _countof(szName)) &&
                !PathIsRelativeW(szName))
            {
                lstrcpynW(szPath, szName, _countof(szPath));
            }
        }
 
        // convert action to event
        fDir = PathIsDirectoryW(szPath);
        dwEvent = ConvertActionToEvent(pInfo->Action, fDir);
 
        // convert SHCNE_DELETE to SHCNE_RMDIR if the path is a directory
        if (!fDir && (dwEvent == SHCNE_DELETE) && m_dir_list.ContainsPath(szPath))
        {
            fDir = TRUE;
            dwEvent = SHCNE_RMDIR;
        }
 
        // update m_dir_list
        switch (dwEvent)
        {
            case SHCNE_MKDIR:
                if (!PathIsDirectoryW(szPath) || !m_dir_list.AddPath(szPath))
                    dwEvent = 0;
                break;
            case SHCNE_CREATE:
                if (!PathFileExistsW(szPath) || PathIsDirectoryW(szPath))
                    dwEvent = 0;
                break;
            case SHCNE_RENAMEFOLDER:
                if (!PathIsDirectoryW(szPath) || !m_dir_list.RenamePath(szTempPath, szPath))
                    dwEvent = 0;
                break;
            case SHCNE_RENAMEITEM:
                if (!PathFileExistsW(szPath) || PathIsDirectoryW(szPath))
                    dwEvent = 0;
                break;
            case SHCNE_RMDIR:
                if (PathIsDirectoryW(szPath) || !m_dir_list.DeletePath(szPath))
                    dwEvent = 0;
                break;
            case SHCNE_DELETE:
                if (PathFileExistsW(szPath))
                    dwEvent = 0;
                break;
        }
 
        if (dwEvent != 0)
        {
            // notify
            if (pInfo->Action == FILE_ACTION_RENAMED_NEW_NAME)
                NotifyFileSystemChange(dwEvent, szTempPath, szPath);
            else
                NotifyFileSystemChange(dwEvent, szPath, NULL);
        }
        else if (pInfo->Action == FILE_ACTION_RENAMED_OLD_NAME)
        {
            // save path for next FILE_ACTION_RENAMED_NEW_NAME
            lstrcpynW(szTempPath, szPath, MAX_PATH);
        }
 
        if (pInfo->NextEntryOffset == 0)
            break; // there is no next entry
 
        // go next entry
        pInfo = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pInfo + pInfo->NextEntryOffset);
    }
 
    TRACE("CDirectoryWatcher::ProcessNotification: leave\n");
}

Referenced by ReadCompletion().

QuitWatching()

void CDirectoryWatcher::QuitWatching

(

)

Definition at line 383 of file CDirectoryWatcher.cpp.

{
    assert(this != NULL);
 
    m_fDead = TRUE;
    CancelIo(m_hDirectory);
}

Referenced by _RequestTerminationAPC().

ReadCompletion()

void CDirectoryWatcher::ReadCompletion	(	DWORD	dwErrorCode,
		DWORD	dwNumberOfBytesTransfered
	)

Definition at line 236 of file CDirectoryWatcher.cpp.

{
    // If the FSD doesn't support directory change notifications, there's no
    // no need to retry and requeue notification
    if (dwErrorCode == ERROR_INVALID_FUNCTION)
    {
        ERR("ERROR_INVALID_FUNCTION\n");
        return;
    }
 
    // Also, if the notify operation was canceled (like, user moved to another
    // directory), then, don't requeue notification.
    if (dwErrorCode == ERROR_OPERATION_ABORTED)
    {
        TRACE("ERROR_OPERATION_ABORTED\n");
        if (IsDead())
            delete this;
        return;
    }
 
    // is this watch dead?
    if (IsDead())
    {
        TRACE("IsDead()\n");
        delete this;
        return;
    }
 
    // This likely means overflow, so force whole directory refresh.
    if (dwNumberOfBytesTransfered == 0)
    {
        // do notify a SHCNE_UPDATEDIR
        NotifyFileSystemChange(SHCNE_UPDATEDIR, m_szDirectoryPath, NULL);
    }
    else
    {
        // do notify
        ProcessNotification();
    }
 
    // restart a watch
    RestartWatching();
}

Referenced by _NotificationCompletion().

RequestAddWatcher()

BOOL CDirectoryWatcher::RequestAddWatcher

(

)

Definition at line 348 of file CDirectoryWatcher.cpp.

{
    assert(this != NULL);
 
    // create an APC thread for directory watching
    if (!CreateAPCThread())
        return FALSE;
 
    // request adding the watch
    QueueUserAPC(_AddDirectoryProcAPC, s_hThreadAPC, (ULONG_PTR)this);
    return TRUE;
}

Referenced by CChangeNotifyServer::OnRegister().

RequestAllWatchersTermination()

void CDirectoryWatcher::RequestAllWatchersTermination ( )

static

Definition at line 374 of file CDirectoryWatcher.cpp.

{
    if (!s_hThreadAPC)
        return;
 
    // request termination of all directory watches
    QueueUserAPC(_RequestAllTerminationAPC, s_hThreadAPC, (ULONG_PTR)NULL);
}

Referenced by CChangeNotifyServer::OnDestroy().

RequestTermination()

BOOL CDirectoryWatcher::RequestTermination

(

)

Definition at line 361 of file CDirectoryWatcher.cpp.

{
    assert(this != NULL);
 
    if (s_hThreadAPC)
    {
        QueueUserAPC(_RequestTerminationAPC, s_hThreadAPC, (ULONG_PTR)this);
        return TRUE;
    }
 
    return FALSE;
}

Referenced by CChangeNotifyServer::DestroyItem().

RestartWatching()

BOOL CDirectoryWatcher::RestartWatching

(

)

Definition at line 307 of file CDirectoryWatcher.cpp.

{
    assert(this != NULL);
 
    if (IsDead())
    {
        delete this;
        return FALSE; // the watch is dead
    }
 
    // initialize the buffer and the overlapped
    ZeroMemory(s_buffer, sizeof(s_buffer));
    ZeroMemory(&m_overlapped, sizeof(m_overlapped));
    m_overlapped.hEvent = (HANDLE)this;
 
    // start the directory watch
    DWORD dwFilter = GetFilterFromEvents(SHCNE_ALLEVENTS);
    if (!ReadDirectoryChangesW(m_hDirectory, s_buffer, sizeof(s_buffer),
                               m_fRecursive, dwFilter, NULL,
                               &m_overlapped, _NotificationCompletion))
    {
        ERR("ReadDirectoryChangesW for '%S' failed (error: %ld)\n",
            m_szDirectoryPath, GetLastError());
        return FALSE; // failure
    }
 
    return TRUE; // success
}

Referenced by _AddDirectoryProcAPC(), and ReadCompletion().

Member Data Documentation

m_dir_list

CDirectoryList CDirectoryWatcher::m_dir_list

protected

Definition at line 34 of file CDirectoryWatcher.h.

Referenced by ProcessNotification().

m_fDead

BOOL CDirectoryWatcher::m_fDead

protected

Definition at line 32 of file CDirectoryWatcher.h.

Referenced by IsDead(), and QuitWatching().

m_fRecursive

BOOL CDirectoryWatcher::m_fRecursive

protected

Definition at line 33 of file CDirectoryWatcher.h.

Referenced by RestartWatching().

m_hDirectory

HANDLE CDirectoryWatcher::m_hDirectory

Definition at line 17 of file CDirectoryWatcher.h.

Referenced by CDirectoryWatcher(), Create(), QuitWatching(), RestartWatching(), and ~CDirectoryWatcher().

m_overlapped

OVERLAPPED CDirectoryWatcher::m_overlapped

protected

Definition at line 35 of file CDirectoryWatcher.h.

Referenced by RestartWatching().

m_szDirectoryPath

WCHAR CDirectoryWatcher::m_szDirectoryPath[MAX_PATH]

Definition at line 18 of file CDirectoryWatcher.h.

Referenced by CDirectoryWatcher(), ProcessNotification(), ReadCompletion(), RestartWatching(), and ~CDirectoryWatcher().

---

The documentation for this class was generated from the following files:

• dll/win32/shell32/shelldesktop/CDirectoryWatcher.h
• dll/win32/shell32/shelldesktop/CDirectoryWatcher.cpp