c++ ReadDirectoryChangesW on directory with symlinks for Directories

Question

I have an application which I use to monitor file/dir changes within a directory. However, this directory also contains symlinks to other directories (which are accessible). However, when I modify a file within a symlink directory, the notification is not triggered. E.g. when I monitor Root:

--Root
  --Dir
    --File1 //Trigger works
  --SDir(Symlink dir)
    --File2 //Trigger won't work

However, when I monitor Root/SDir, which is the symlink directory than the trigger on File2 works correctly. E.g.:

--SDir
  --File2 //Trigger works

So when the symlink directory is not the root, it won't trigger on file changes within that directory. However, when I set the symlink directory as the root, it works fine. And yes, the bWatchSubtree parameter within the ReadDirectoryChangesW-function is set to true.

For the good order, I open the directory handle using the CreateFile function:

CreateFile(
    Dir, //Root or Root/SDir in this example
    FILE_LIST_DIRECTORY,
    FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE,
    NULL,
    OPEN_EXISTING,
    FILE_FLAG_BACKUP_SEMANTICS,
    NULL);

So, why won't the trigger work on files within symlinks if that same symlink is not the root of ReadDirectoryChangesW?

Answer 1

Here's one way to set up watch over an entire tree... These are excepts from my code base, I can't put the entire code here because of dependencies...

Usage:

   FolderWatchInfo fwi;
   fwi.Create(strRootPath,  TRUE, 
        FolderWatchInfo::flagDirWatch | FolderWatchInfo::flagFileWatch);

    WaitForSingleObject(fwi.GetHandle(), INFINITE);  // or the usual WaitForMultipleObjects(...)
                                                     // with an exit event
    //...
    //On event signaled:

    CStringsVector vFolders;
    fwi.GetSubDirChangeList(vFolders);
    Sleep(1000);        // give a little time for things to settle...

    for each (const CIRString& str in vFolders)
    {
       OnFolderChange(str);  // signal my app
    }

Events are automatic reset, so there's no maintenance to do on that.

Stuff that's not there:

CIRSingleLock is like lock_guard

DirScanner is a wrapper around FindFirstFile(), it reports folders to the Reader struct.

include file:

// *********************************************************************************************************************************
// *********************************************************************************************************************************

#pragma once

#include <DirScanner.h>
#include <shared_ptr.h>
#include <boost/weak_ptr.hpp>
#include <vector>
#include <IRSingleLock.h>

// *********************************************************************************************************************************
// *********************************************************************************************************************************

class FolderWatchInfo
{
    // --------------------------------------------------------------------------------------------------------------------------------

public:
    enum Flags
    {
        flagFileCreateDelete  = FILE_NOTIFY_CHANGE_FILE_NAME,
        flagFileModify        = FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE,
        flagFileSecurity      = FILE_NOTIFY_CHANGE_SECURITY,
        flagFileAttributes    = FILE_NOTIFY_CHANGE_ATTRIBUTES,
        flagDirCreateDetelete = FILE_NOTIFY_CHANGE_DIR_NAME,

        flagFileWatch = flagFileCreateDelete | flagFileModify,
        flagDirWatch  = flagDirCreateDetelete,
    };

    // --------------------------------------------------------------------------------------------------------------------------------

    typedef shared_ptr<FolderWatchInfo> FolderWatchInfoPtr;
    typedef std::vector<FolderWatchInfoPtr> FWIVector;
    typedef std::vector<CIRString> CStringsVector;

    // --------------------------------------------------------------------------------------------------------------------------------
private:
    struct Reader : public DirScanner::Reader
    {
        FolderWatchInfo& fwi;

        Reader(FolderWatchInfo& fwi_) 
            : DirScanner::Reader(fwi_.GetPathName(), _T("__NOFILES__"), 1)
            ,  fwi(fwi_)
        { }

        virtual bool OnDirectoryFound(LPCTSTR szPathName, const WIN32_FIND_DATA& findData)
        {
            FolderWatchInfoPtr p = make_shared<FolderWatchInfo>();
            p->Create(fwi.GetPathName() + _T("\\") + szPathName, fwi.GetFlags());
            fwi.m_vChildren.push_back(p);
            return TRUE;
        }
    };

    friend struct Reader;

private:
    CIRCriticalSection m_lock;
    weak_ptr<FolderWatchInfo> m_pParent;
    CIRString m_strPathName;
    HANDLE m_hWatchEvent;
    DWORD m_dwFlags;
    FWIVector m_vChildren;

    // --------------------------------------------------------------------------------------------------------------------------------

private:
    inline FolderWatchInfo(const FolderWatchInfo&) {}
    inline bool operator = (const FolderWatchInfo&) {}

    // --------------------------------------------------------------------------------------------------------------------------------

public:
    FolderWatchInfo();
    ~FolderWatchInfo();

    // --------------------------------------------------------------------------------------------------------------------------------

    HANDLE Create(const CIRString& strPathName, BOOL bRecursive, DWORD dwFlags);
    void CloseHandle();
    void ResetEvent();

protected:
    HANDLE Create(const CIRString& strPathName, DWORD dwFlags);
    void AddToSubDirChangeList(CStringsVector& vSubDirs);

    // --------------------------------------------------------------------------------------------------------------------------------
public:
    inline HANDLE GetHandle() const
    {
        return m_hWatchEvent;
    }

    // --------------------------------------------------------------------------------------------------------------------------------

    inline void GetSubDirChangeList(CStringsVector& vSubDirs)
    {
        CIRSingleLock lock(m_lock);
        vSubDirs.clear();
        AddToSubDirChangeList(vSubDirs);
    }

    // --------------------------------------------------------------------------------------------------------------------------------

    inline FolderWatchInfoPtr GetParent() const
    {
        return FolderWatchInfoPtr(m_pParent, boost::detail::sp_nothrow_tag());
    }

    // --------------------------------------------------------------------------------------------------------------------------------

    inline const FWIVector& GetChildren() const
    {
        return m_vChildren;
    }

    // --------------------------------------------------------------------------------------------------------------------------------

    inline const CIRString& GetPathName() const
    {
        return m_strPathName;
    }

    // --------------------------------------------------------------------------------------------------------------------------------

    inline DWORD GetFlags() const
    {
        return m_dwFlags;
    }

    // --------------------------------------------------------------------------------------------------------------------------------

    inline bool operator == (LPCTSTR szPath)
    {
        return (m_strPathName.CompareNoCase(szPath) == 0);
    }
};

// ***************************************************************************************************************************** EOF

cpp.

// *********************************************************************************************************************************
// *********************************************************************************************************************************

#include "StdAfx.h"
#include "FolderWatchInfo.h"

// *********************************************************************************************************************************

FolderWatchInfo::FolderWatchInfo()
    : m_hWatchEvent(INVALID_HANDLE_VALUE)
    , m_dwFlags(0)
{ }

// *********************************************************************************************************************************

FolderWatchInfo::~FolderWatchInfo(void)
{
    CIRSingleLock lock(m_lock);
    if (m_hWatchEvent != INVALID_HANDLE_VALUE)
    {
        FindCloseChangeNotification(m_hWatchEvent);
    }
}

// *********************************************************************************************************************************

HANDLE FolderWatchInfo::Create(const CIRString& strPathName, BOOL bRecursive, DWORD dwFlags)
{
    CIRSingleLock lock(m_lock);

    ASSERT(m_hWatchEvent == INVALID_HANDLE_VALUE);
    m_strPathName = CleanPathName(strPathName);
    m_dwFlags = dwFlags;
    m_hWatchEvent = FindFirstChangeNotification(m_strPathName, bRecursive, dwFlags);

    if (bRecursive)
    {
        DirScanner().ScanFolder(Reader(*this));
    }
    return m_hWatchEvent;
}

// *********************************************************************************************************************************

HANDLE FolderWatchInfo::Create(const CIRString& strPathName, DWORD dwFlags)
{
    CIRSingleLock lock(m_lock);

    ASSERT(m_hWatchEvent == INVALID_HANDLE_VALUE);

    m_strPathName = CleanPathName(strPathName);
    m_dwFlags = dwFlags;
    m_hWatchEvent = FindFirstChangeNotification(m_strPathName, FALSE, dwFlags);
    DirScanner().ScanFolder(Reader(*this));
    return m_hWatchEvent;
}

// *********************************************************************************************************************************

void FolderWatchInfo::CloseHandle()
{
    CIRSingleLock lock(m_lock);

    if (m_hWatchEvent != INVALID_HANDLE_VALUE)
    {
        FindCloseChangeNotification(m_hWatchEvent);
        m_hWatchEvent = INVALID_HANDLE_VALUE;
    }
}

// *********************************************************************************************************************************

void FolderWatchInfo::ResetEvent()
{
    if (m_hWatchEvent != INVALID_HANDLE_VALUE)
    {
        while (WAIT_OBJECT_0 == WaitForSingleObject(m_hWatchEvent, 0))
        {
            if (!FindNextChangeNotification(m_hWatchEvent))
            {
                CloseHandle();
                break;
            }
        }
    }
}

// *********************************************************************************************************************************

void FolderWatchInfo::AddToSubDirChangeList(CStringsVector& vSubDirs)
{
    CIRSingleLock lock(m_lock);

    if (WAIT_OBJECT_0 == WaitForSingleObject(m_hWatchEvent, 0))
    {
        ResetEvent();
        vSubDirs.push_back(m_strPathName);
    }
    for each (const FolderWatchInfoPtr& p in m_vChildren)
    {
        p->AddToSubDirChangeList(vSubDirs);
    }
}

// ***************************************************************************************************************************** EOF

Answer 2

filesystem send you notification only when files changed inside folder. symbolic link (or mount point) this is only file inside folder, which point to another file/folder. if target file/directory not inside our original folder - we and not get notification about changes inside this target folder

when you open direct symbolic link (or mount point) without FILE_FLAG_OPEN_REPARSE_POINT you really open target directory (to which point this symlink) and got notify from this directory

for got notification from some folder usually need do next:

• create class, which encapsulate folder handle and all data which you need for process notification from this directory (for example it full path, etc)
• open directory handle with FILE_FLAG_OVERLAPPED for process ReadDirectoryChangesW asynchronous
• call BindIoCompletionCallback for opened handle - as result you callback will be called when notification come from filesystem.
• first time direct call ReadDirectoryChangesW and next time call it from callback (registered via BindIoCompletionCallback) until we not got ERROR_NOTIFY_CLEANUP
• when we want stop notification process - need close directory handle. as result current active query will be just completed with ERROR_NOTIFY_CLEANUP
• need of course implement reference counting and handle rundown protection (for not use it after close) in class.

with this class we can have any count of directory spy - need simply create N instances of this class. nothing need wait, loops etc. simply continue do your task. when you no more need notification from directory - close it handle and release structure

simplest implementation:

class SPYDATA : public OVERLAPPED, RUNDOWN_REF
{
    HANDLE m_hFile;
    DWORD _dwNotifyFilter;
    LONG _dwRef;
    UCHAR _buf[PAGE_SIZE];

    ~SPYDATA()
    {
        Close();
        DbgPrint("%s<%p>\n", __FUNCTION__, this);
    }

    void DumpDirectoryChanges()
    {
        union {
            PVOID buf;
            PBYTE pb;
            PFILE_NOTIFY_INFORMATION pfni;
        };

        buf = _buf;

        for (;;)
        {
            DbgPrint("[%03x] %x <%.*S>\n", _dwNotifyFilter, pfni->Action, pfni->FileNameLength >> 1, pfni->FileName);

            ULONG NextEntryOffset = pfni->NextEntryOffset;

            if (!NextEntryOffset)
            {
                break;
            }

            pb += NextEntryOffset;
        }
    }

    void IOCompletionRoutine(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered)
    {
        switch (dwErrorCode)
        {
        case ERROR_NOTIFY_CLEANUP:
            DbgPrint("%p>[%x] ---- NOTIFY_CLEANUP -----\n", this, _dwNotifyFilter);
            return ;
        case NOERROR:
            if (dwNumberOfBytesTransfered) DumpDirectoryChanges();
            DoRead();
            return;
        }

        DbgPrint("%p>[%x] error=%x\n", this, _dwNotifyFilter, dwErrorCode);
    }

    void IOCompletionRoutineAndRelease(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered)
    {
        IOCompletionRoutine(dwErrorCode, dwNumberOfBytesTransfered);
        Release();
    }

    static VOID CALLBACK _IOCompletionRoutine(
        __in  DWORD status,
        __in  DWORD dwNumberOfBytesTransfered,
        __in  LPOVERLAPPED lpOverlapped
        )
    {
        static_cast<SPYDATA*>(lpOverlapped)->IOCompletionRoutineAndRelease(RtlNtStatusToDosError(status), dwNumberOfBytesTransfered);
    }

    virtual void RundownCompleted()
    {
        if (m_hFile) CloseHandle(m_hFile);
    }

public:

    void AddRef()
    {
        InterlockedIncrement(&_dwRef);
    }

    void Release()
    {
        if (!InterlockedDecrement(&_dwRef)) delete this;
    }

    SPYDATA(DWORD dwNotifyFilter) : _dwNotifyFilter(dwNotifyFilter)
    {
        _dwRef = 1;
        m_hFile = 0;
        RtlZeroMemory(static_cast<OVERLAPPED*>(this), sizeof(OVERLAPPED));
        DbgPrint("%s<%p>\n", __FUNCTION__, this);
    }

    void DoRead()
    {
        if (AcquireRundownProtection())
        {
            AddRef();

            ULONG dwErrorCode = ReadDirectoryChangesW(m_hFile, _buf, sizeof(_buf), 
                TRUE, _dwNotifyFilter, NULL, this, NULL) ? NOERROR : GetLastError();

            ReleaseRundownProtection();

            switch (dwErrorCode)
            {
            case NOERROR:
            case ERROR_IO_PENDING:
                break;
            default:
                IOCompletionRoutineAndRelease(dwErrorCode, 0);
            }
        }
    }

    ULONG Open(PCWSTR lpFileName )
    {
        HANDLE hFile = CreateFile(lpFileName, FILE_GENERIC_READ, FILE_SHARE_VALID_FLAGS, 0, 
            OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS|FILE_FLAG_OVERLAPPED, 0);

        if (hFile != INVALID_HANDLE_VALUE)
        {
            if (BindIoCompletionCallback(hFile, _IOCompletionRoutine, 0))
            {
                m_hFile = hFile;

                return NOERROR;
            }
            CloseHandle(hFile);
        }

        return GetLastError();
    }

    void Close()
    {
        BeginRundown();
    }
};

BOOL CreateSpy(DWORD dwNotifyFilter, PCWSTR lpFileName, SPYDATA** pp)
{
    if (SPYDATA* p = new SPYDATA(dwNotifyFilter))
    {
        ULONG dwError = p->Open(lpFileName);

        if (!dwError)
        {
            *pp = p;
            p->DoRead();
            return NOERROR;
        }

        p->Release();

        return dwError;
    }

    return ERROR_NO_SYSTEM_RESOURCES;
}

void DestroySpyData(SPYDATA* p)
{
    if (p) 
    {
        p->Close();
        p->Release();
    }
}

and use it as:

SPYDATA* p;
if (!CreateSpy(FILE_NOTIFY_VALID_MASK, L"<some path>", &p))
{
    MessageBoxW(0,0,0,0);// really here any code
    DestroySpyData(p);
}

my implementation of rundown protection (it not implemented by api in user mode) is

#define RUNDOWN_INIT_VALUE 0x80000000
#define RUNDOWN_COMPLETE_VALUE 0
#define ObpBeginRundown(p) _interlockedbittestandreset(p, 31)
#define ObpUnlock _InterlockedDecrement

__forceinline BOOL ObpLock(PLONG pLock)
{
    LONG Value = *pLock, NewValue;

    for ( ; Value; Value = NewValue)
    {
        NewValue = _InterlockedCompareExchange(pLock, Value + 1, Value);

        if (NewValue == Value) return TRUE;
    }

    return FALSE;
}

__forceinline BOOL ObpAcquireRundownProtection(PLONG pLock)
{
    LONG Value = *pLock, NewValue;

    for ( ; Value < 0; Value = NewValue)
    {
        NewValue = _InterlockedCompareExchange(pLock, Value + 1, Value);

        if (NewValue == Value) return TRUE;
    }

    return FALSE;
}

class __declspec(novtable) RUNDOWN_REF
{
    LONG _LockCount;

protected:

    virtual void RundownCompleted() = 0;

public:

    BOOL IsRundownBegin()
    {
        return 0 <= _LockCount;
    }

    __forceinline void Reinit()
    {
        if (InterlockedCompareExchange(&_LockCount, RUNDOWN_INIT_VALUE, RUNDOWN_COMPLETE_VALUE) != RUNDOWN_COMPLETE_VALUE)
        {
            __debugbreak();
        }
    }

    __forceinline RUNDOWN_REF()
    {
        _LockCount = RUNDOWN_INIT_VALUE;
    }

    __forceinline BOOL AcquireRundownProtection()
    {
        return ObpAcquireRundownProtection(&_LockCount);
    }

    __forceinline void ReleaseRundownProtection()
    {
        if (!_InterlockedDecrement(&_LockCount))
        {
            RundownCompleted();
        }
    }

    void BeginRundown()
    {
        if (AcquireRundownProtection())
        {
            ObpBeginRundown(&_LockCount);
            ReleaseRundownProtection();
        }
    }
};