[wxWidgets.git] / src / unix / fswatcher_inotify.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/unix/fswatcher_inotify.cpp
// Purpose:     inotify-based wxFileSystemWatcher implementation
// Author:      Bartosz Bekier
// Created:     2009-05-26
// RCS-ID:      $Id$
// Copyright:   (c) 2009 Bartosz Bekier <bartosz.bekier@gmail.com>
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_FSWATCHER

#include "wx/fswatcher.h"

#ifdef wxHAS_INOTIFY

#include <sys/inotify.h>
#include <unistd.h>
#include "wx/private/fswatcher.h"

// ============================================================================
// wxFSWatcherImpl implementation & helper wxFSWSourceHandler implementation
// ============================================================================

// inotify watch descriptor => wxFSWatchEntry* map
WX_DECLARE_HASH_MAP(int, wxFSWatchEntry*, wxIntegerHash, wxIntegerEqual,
                                              wxFSWatchEntryDescriptors);

// inotify event cookie => inotify_event* map
WX_DECLARE_HASH_MAP(int, inotify_event*, wxIntegerHash, wxIntegerEqual,
                                                      wxInotifyCookies);

/**
 * Helper class encapsulating inotify mechanism
 */
class wxFSWatcherImplUnix : public wxFSWatcherImpl
{
public:
    wxFSWatcherImplUnix(wxFileSystemWatcherBase* watcher) :
        wxFSWatcherImpl(watcher),
        m_source(NULL),
        m_ifd(-1)
    {
        m_handler = new wxFSWSourceHandler(this);
    }

    ~wxFSWatcherImplUnix()
    {
        // we close inotify only if initialized before
        if (IsOk())
        {
            Close();
        }

        delete m_handler;
    }

    bool Init()
    {
        wxCHECK_MSG( !IsOk(), false, "Inotify already initialized" );

        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
        wxCHECK_MSG( loop, false, "File system watcher needs an event loop" );

        m_ifd = inotify_init();
        if ( m_ifd == -1 )
        {
            wxLogSysError( _("Unable to create inotify instance") );
            return false;
        }

        m_source = loop->AddSourceForFD
                         (
                          m_ifd,
                          m_handler,
                          wxEVENT_SOURCE_INPUT | wxEVENT_SOURCE_EXCEPTION
                         );

        return m_source != NULL;
    }

    void Close()
    {
        wxCHECK_RET( IsOk(),
                    "Inotify not initialized or invalid inotify descriptor" );

        delete m_source;
        m_source = NULL;

        if ( close(m_ifd) != 0 )
        {
            wxLogSysError( _("Unable to close inotify instance") );
        }
    }

    virtual bool DoAdd(wxSharedPtr<wxFSWatchEntryUnix> watch)
    {
        wxCHECK_MSG( IsOk(), false,
                    "Inotify not initialized or invalid inotify descriptor" );

        int wd = DoAddInotify(watch.get());
        if (wd == -1)
        {
            wxLogSysError( _("Unable to add inotify watch") );
            return false;
        }

        wxFSWatchEntryDescriptors::value_type val(wd, watch.get());
        if (!m_watchMap.insert(val).second)
        {
            wxFAIL_MSG( wxString::Format( "Path %s is already watched",
                                           watch->GetPath()) );
            return false;
        }

        return true;
    }

    virtual bool DoRemove(wxSharedPtr<wxFSWatchEntryUnix> watch)
    {
        wxCHECK_MSG( IsOk(), false,
                    "Inotify not initialized or invalid inotify descriptor" );

        int ret = DoRemoveInotify(watch.get());
        if (ret == -1)
        {
            wxLogSysError( _("Unable to remove inotify watch") );
            return false;
        }

        if (m_watchMap.erase(watch->GetWatchDescriptor()) != 1)
        {
            wxFAIL_MSG( wxString::Format("Path %s is not watched",
                                          watch->GetPath()) );
        }
        watch->SetWatchDescriptor(-1);
        return true;
    }

    virtual bool RemoveAll()
    {
        wxFSWatchEntries::iterator it = m_watches.begin();
        for ( ; it != m_watches.end(); ++it )
        {
            (void) DoRemove(it->second);
        }
        m_watches.clear();
        return true;
    }

    int ReadEvents()
    {
        wxCHECK_MSG( IsOk(), -1,
                    "Inotify not initialized or invalid inotify descriptor" );

        // read events
        // TODO differentiate depending on params
        char buf[128 * sizeof(inotify_event)];
        int left = ReadEventsToBuf(buf, sizeof(buf));
        if (left == -1)
            return -1;

        // left > 0, we have events
        char* memory = buf;
        int event_count = 0;
        while (left > 0) // OPT checking 'memory' would suffice
        {
            event_count++;
            inotify_event* e = (inotify_event*)memory;

            // process one inotify_event
            ProcessNativeEvent(*e);

            int offset = sizeof(inotify_event) + e->len;
            left -= offset;
            memory += offset;
        }

        // take care of unmatched renames
        ProcessRenames();

        wxLogTrace(wxTRACE_FSWATCHER, "We had %d native events", event_count);
        return event_count;
    }

    bool IsOk() const
    {
        return m_source != NULL;
    }

protected:
    int DoAddInotify(wxFSWatchEntry* watch)
    {
        int flags = Watcher2NativeFlags(watch->GetFlags());
        int wd = inotify_add_watch(m_ifd, watch->GetPath().fn_str(), flags);
        // finally we can set watch descriptor
        watch->SetWatchDescriptor(wd);
        return wd;
    }

    int DoRemoveInotify(wxFSWatchEntry* watch)
    {
        return inotify_rm_watch(m_ifd, watch->GetWatchDescriptor());
    }

    void ProcessNativeEvent(const inotify_event& inevt)
    {
        wxLogTrace(wxTRACE_FSWATCHER, InotifyEventToString(inevt));

        // after removing inotify watch we get IN_IGNORED for it, but the watch
        // will be already removed from our list at that time
        if (inevt.mask & IN_IGNORED)
        {
            return;
        }

        // get watch entry for this event
        wxFSWatchEntryDescriptors::iterator it = m_watchMap.find(inevt.wd);
        wxCHECK_RET(it != m_watchMap.end(),
                             "Watch descriptor not present in the watch map!");

        wxFSWatchEntry& watch = *(it->second);
        int nativeFlags = inevt.mask;
        int flags = Native2WatcherFlags(nativeFlags);

        // check out for error/warning condition
        if (flags & wxFSW_EVENT_WARNING || flags & wxFSW_EVENT_ERROR)
        {
            wxString errMsg = GetErrorDescription(Watcher2NativeFlags(flags));
            wxFileSystemWatcherEvent event(flags, errMsg);
            SendEvent(event);
        }
        // filter out ignored events and those not asked for.
        // we never filter out warnings or exceptions
        else if ((flags == 0) || !(flags & watch.GetFlags()))
        {
            return;
        }
        // renames
        else if (nativeFlags & IN_MOVE)
        {
            wxInotifyCookies::iterator it = m_cookies.find(inevt.cookie);
            if ( it == m_cookies.end() )
            {
                int size = sizeof(inevt) + inevt.len;
                inotify_event* e = (inotify_event*) operator new (size);
                memcpy(e, &inevt, size);

                wxInotifyCookies::value_type val(e->cookie, e);
                m_cookies.insert(val);
            }
            else
            {
                inotify_event& oldinevt = *(it->second);

                wxFileSystemWatcherEvent event(flags);
                if ( inevt.mask & IN_MOVED_FROM )
                {
                    event.SetPath(GetEventPath(watch, inevt));
                    event.SetNewPath(GetEventPath(watch, oldinevt));
                }
                else
                {
                    event.SetPath(GetEventPath(watch, oldinevt));
                    event.SetNewPath(GetEventPath(watch, inevt));
                }
                SendEvent(event);

                m_cookies.erase(it);
                delete &oldinevt;
            }
        }
        // every other kind of event
        else
        {
            wxFileName path = GetEventPath(watch, inevt);
            wxFileSystemWatcherEvent event(flags, path, path);
            SendEvent(event);
        }
    }

    void ProcessRenames()
    {
        wxInotifyCookies::iterator it = m_cookies.begin();
        while ( it != m_cookies.end() )
        {
            inotify_event& inevt = *(it->second);

            wxLogTrace(wxTRACE_FSWATCHER, "Processing pending rename events");
            wxLogTrace(wxTRACE_FSWATCHER, InotifyEventToString(inevt));

            // get watch entry for this event
            wxFSWatchEntryDescriptors::iterator wit = m_watchMap.find(inevt.wd);
            wxCHECK_RET(wit != m_watchMap.end(),
                             "Watch descriptor not present in the watch map!");

            wxFSWatchEntry& watch = *(wit->second);
            int flags = Native2WatcherFlags(inevt.mask);
            wxFileName path = GetEventPath(watch, inevt);
            wxFileSystemWatcherEvent event(flags, path, path);
            SendEvent(event);

            m_cookies.erase(it);
            delete &inevt;
            it = m_cookies.begin();
        }
    }

    void SendEvent(wxFileSystemWatcherEvent& evt)
    {
        wxLogTrace(wxTRACE_FSWATCHER, evt.ToString());
        m_watcher->GetOwner()->ProcessEvent(evt);
    }

    int ReadEventsToBuf(char* buf, int size)
    {
        wxCHECK_MSG( IsOk(), false,
                    "Inotify not initialized or invalid inotify descriptor" );

        memset(buf, 0, size);
        ssize_t left = read(m_ifd, buf, size);
        if (left == -1)
        {
            wxLogSysError(_("Unable to read from inotify descriptor"));
            return -1;
        }
        else if (left == 0)
        {
            wxLogWarning(_("EOF while reading from inotify descriptor"));
            return -1;
        }

        return left;
    }

    static wxString InotifyEventToString(const inotify_event& inevt)
    {
        wxString mask = (inevt.mask & IN_ISDIR) ?
                        wxString::Format("IS_DIR | %u", inevt.mask & ~IN_ISDIR) :
                        wxString::Format("%u", inevt.mask);
        return wxString::Format("Event: wd=%d, mask=%s, cookie=%u, len=%u, "
                                "name=%s", inevt.wd, mask, inevt.cookie,
                                inevt.len, inevt.name);
    }

    static wxFileName GetEventPath(const wxFSWatchEntry& watch,
                                   const inotify_event& inevt)
    {
        // only when dir is watched, we have non-empty e.name
        wxFileName path = watch.GetPath();
        if (path.IsDir())
        {
            path = wxFileName(path.GetPath(), inevt.name);
        }
        return path;
    }

    static int Watcher2NativeFlags(int WXUNUSED(flags))
    {
        // TODO: it would be nice to subscribe only to the events we really need
        return IN_ALL_EVENTS;
    }

    static int Native2WatcherFlags(int flags)
    {
        static const int flag_mapping[][2] = {
            { IN_ACCESS,        wxFSW_EVENT_ACCESS }, // generated during read!
            { IN_MODIFY,        wxFSW_EVENT_MODIFY },
            { IN_ATTRIB,        0 },
            { IN_CLOSE_WRITE,   0 },
            { IN_CLOSE_NOWRITE, 0 },
            { IN_OPEN,          0 },
            { IN_MOVED_FROM,    wxFSW_EVENT_RENAME },
            { IN_MOVED_TO,      wxFSW_EVENT_RENAME },
            { IN_CREATE,        wxFSW_EVENT_CREATE },
            { IN_DELETE,        wxFSW_EVENT_DELETE },
            { IN_DELETE_SELF,   wxFSW_EVENT_DELETE },
            { IN_MOVE_SELF,     wxFSW_EVENT_DELETE },

            { IN_UNMOUNT,       wxFSW_EVENT_ERROR  },
            { IN_Q_OVERFLOW,    wxFSW_EVENT_WARNING},

            // ignored, because this is genereted mainly by watcher::Remove()
            { IN_IGNORED,        0 }
        };

        unsigned int i=0;
        for ( ; i < WXSIZEOF(flag_mapping); ++i) {
            // in this mapping multiple flags at once don't happen
            if (flags & flag_mapping[i][0])
                return flag_mapping[i][1];
        }

        // never reached
        wxFAIL_MSG(wxString::Format("Unknown inotify event mask %u", flags));
        return -1;
    }

    /**
     * Returns error description for specified inotify mask
     */
    static const wxString GetErrorDescription(int flag)
    {
        switch ( flag )
        {
        case IN_UNMOUNT:
            return _("File system containing watched object was unmounted");
        case IN_Q_OVERFLOW:
            return _("Event queue overflowed");
        }

        // never reached
        wxFAIL_MSG(wxString::Format("Unknown inotify event mask %u", flag));
        return wxEmptyString;
    }

    wxFSWSourceHandler* m_handler;        // handler for inotify event source
    wxFSWatchEntryDescriptors m_watchMap; // inotify wd=>wxFSWatchEntry* map
    wxInotifyCookies m_cookies;           // map to track renames
    wxEventLoopSource* m_source;          // our event loop source

    // file descriptor created by inotify_init()
    int m_ifd;
};


// ============================================================================
// wxFSWSourceHandler implementation
// ============================================================================

// once we get signaled to read, actuall event reading occurs
void wxFSWSourceHandler::OnReadWaiting()
{
    wxLogTrace(wxTRACE_FSWATCHER, "--- OnReadWaiting ---");
    m_service->ReadEvents();
}

void wxFSWSourceHandler::OnWriteWaiting()
{
    wxFAIL_MSG("We never write to inotify descriptor.");
}

void wxFSWSourceHandler::OnExceptionWaiting()
{
    wxFAIL_MSG("We never receive exceptions on inotify descriptor.");
}


// ============================================================================
// wxInotifyFileSystemWatcher implementation
// ============================================================================

wxInotifyFileSystemWatcher::wxInotifyFileSystemWatcher()
    : wxFileSystemWatcherBase()
{
    Init();
}

wxInotifyFileSystemWatcher::wxInotifyFileSystemWatcher(const wxFileName& path,
                                                       int events)
    : wxFileSystemWatcherBase()
{
    if (!Init())
    {
        if (m_service)
            delete m_service;
        return;
    }

    Add(path, events);
}

wxInotifyFileSystemWatcher::~wxInotifyFileSystemWatcher()
{
}

bool wxInotifyFileSystemWatcher::Init()
{
    m_service = new wxFSWatcherImplUnix(this);
    return m_service->Init();
}

#endif // wxHAS_INOTIFY

#endif // wxUSE_FSWATCHER
Commit	Line	Data
6b8ef0b3 VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/unix/fswatcher_inotify.cpp
	3	// Purpose: inotify-based wxFileSystemWatcher implementation
	4	// Author: Bartosz Bekier
	5	// Created: 2009-05-26
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2009 Bartosz Bekier <bartosz.bekier@gmail.com>
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#if wxUSE_FSWATCHER
	19
	20	#include "wx/fswatcher.h"
	21
	22	#ifdef wxHAS_INOTIFY
	23
	24	#include <sys/inotify.h>
	25	#include <unistd.h>
	26	#include "wx/private/fswatcher.h"
	27
	28	// ============================================================================
	29	// wxFSWatcherImpl implementation & helper wxFSWSourceHandler implementation
	30	// ============================================================================
	31
	32	// inotify watch descriptor => wxFSWatchEntry* map
	33	WX_DECLARE_HASH_MAP(int, wxFSWatchEntry*, wxIntegerHash, wxIntegerEqual,
	34	wxFSWatchEntryDescriptors);
	35
	36	// inotify event cookie => inotify_event* map
	37	WX_DECLARE_HASH_MAP(int, inotify_event*, wxIntegerHash, wxIntegerEqual,
	38	wxInotifyCookies);
	39
	40	/**
	41	* Helper class encapsulating inotify mechanism
	42	*/
	43	class wxFSWatcherImplUnix : public wxFSWatcherImpl
	44	{
	45	public:
	46	wxFSWatcherImplUnix(wxFileSystemWatcherBase* watcher) :
	47	wxFSWatcherImpl(watcher),
5cd99866 VZ	48	m_source(NULL),
5cd99866 VZ	49	m_ifd(-1)
6b8ef0b3 VZ	50	{
	51	m_handler = new wxFSWSourceHandler(this);
	52	}
	53
	54	~wxFSWatcherImplUnix()
	55	{
	56	// we close inotify only if initialized before
	57	if (IsOk())
	58	{
	59	Close();
	60	}
	61
	62	delete m_handler;
	63	}
	64
	65	bool Init()
	66	{
	67	wxCHECK_MSG( !IsOk(), false, "Inotify already initialized" );
6b8ef0b3	68
5cd99866 VZ	69	wxEventLoopBase *loop = wxEventLoopBase::GetActive();
5cd99866 VZ	70	wxCHECK_MSG( loop, false, "File system watcher needs an event loop" );
6b8ef0b3	71
5cd99866 VZ	72	m_ifd = inotify_init();
5cd99866 VZ	73	if ( m_ifd == -1 )
6b8ef0b3 VZ	74	{
	75	wxLogSysError( _("Unable to create inotify instance") );
	76	return false;
	77	}
	78
5cd99866 VZ	79	m_source = loop->AddSourceForFD
	80	(
	81	m_ifd,
	82	m_handler,
	83	wxEVENT_SOURCE_INPUT \| wxEVENT_SOURCE_EXCEPTION
	84	);
	85
	86	return m_source != NULL;
6b8ef0b3 VZ	87	}
6b8ef0b3 VZ	88
5cd99866	89	void Close()
6b8ef0b3	90	{
5cd99866	91	wxCHECK_RET( IsOk(),
6b8ef0b3	92	"Inotify not initialized or invalid inotify descriptor" );
6b8ef0b3	93
5cd99866 VZ	94	delete m_source;
5cd99866 VZ	95	m_source = NULL;
6b8ef0b3	96
5cd99866	97	if ( close(m_ifd) != 0 )
6b8ef0b3 VZ	98	{
	99	wxLogSysError( _("Unable to close inotify instance") );
	100	}
6b8ef0b3 VZ	101	}
	102
	103	virtual bool DoAdd(wxSharedPtr<wxFSWatchEntryUnix> watch)
	104	{
	105	wxCHECK_MSG( IsOk(), false,
	106	"Inotify not initialized or invalid inotify descriptor" );
	107
	108	int wd = DoAddInotify(watch.get());
	109	if (wd == -1)
	110	{
	111	wxLogSysError( _("Unable to add inotify watch") );
	112	return false;
	113	}
	114
	115	wxFSWatchEntryDescriptors::value_type val(wd, watch.get());
	116	if (!m_watchMap.insert(val).second)
	117	{
	118	wxFAIL_MSG( wxString::Format( "Path %s is already watched",
	119	watch->GetPath()) );
	120	return false;
	121	}
	122
	123	return true;
	124	}
	125
	126	virtual bool DoRemove(wxSharedPtr<wxFSWatchEntryUnix> watch)
	127	{
	128	wxCHECK_MSG( IsOk(), false,
	129	"Inotify not initialized or invalid inotify descriptor" );
	130
	131	int ret = DoRemoveInotify(watch.get());
	132	if (ret == -1)
	133	{
	134	wxLogSysError( _("Unable to remove inotify watch") );
	135	return false;
	136	}
	137
	138	if (m_watchMap.erase(watch->GetWatchDescriptor()) != 1)
	139	{
	140	wxFAIL_MSG( wxString::Format("Path %s is not watched",
	141	watch->GetPath()) );
	142	}
	143	watch->SetWatchDescriptor(-1);
	144	return true;
	145	}
	146
	147	virtual bool RemoveAll()
	148	{
	149	wxFSWatchEntries::iterator it = m_watches.begin();
	150	for ( ; it != m_watches.end(); ++it )
	151	{
	152	(void) DoRemove(it->second);
	153	}
	154	m_watches.clear();
	155	return true;
	156	}
	157
	158	int ReadEvents()
	159	{
	160	wxCHECK_MSG( IsOk(), -1,
	161	"Inotify not initialized or invalid inotify descriptor" );
	162
	163	// read events
	164	// TODO differentiate depending on params
165	char buf[128 * sizeof(inotify_event)];
166	int left = ReadEventsToBuf(buf, sizeof(buf));
167	if (left == -1)
168	return -1;
169
170	// left > 0, we have events
171	char* memory = buf;
172	int event_count = 0;
173	while (left > 0) // OPT checking 'memory' would suffice
174	{
175	event_count++;
176	inotify_event* e = (inotify_event*)memory;
177
178	// process one inotify_event
179	ProcessNativeEvent(*e);
180
181	int offset = sizeof(inotify_event) + e->len;
182	left -= offset;
183	memory += offset;
184	}
185
186	// take care of unmatched renames
187	ProcessRenames();
188
189	wxLogTrace(wxTRACE_FSWATCHER, "We had %d native events", event_count);
190	return event_count;
191	}
192
5cd99866	193	bool IsOk() const
6b8ef0b3	194	{
5cd99866	195	return m_source != NULL;
6b8ef0b3 VZ	196	}
	197
	198	protected:
6b8ef0b3 VZ	199	int DoAddInotify(wxFSWatchEntry* watch)
	200	{
	201	int flags = Watcher2NativeFlags(watch->GetFlags());
5cd99866	202	int wd = inotify_add_watch(m_ifd, watch->GetPath().fn_str(), flags);
6b8ef0b3 VZ	203	// finally we can set watch descriptor
	204	watch->SetWatchDescriptor(wd);
	205	return wd;
	206	}
	207
	208	int DoRemoveInotify(wxFSWatchEntry* watch)
	209	{
5cd99866	210	return inotify_rm_watch(m_ifd, watch->GetWatchDescriptor());
6b8ef0b3 VZ	211	}
	212
	213	void ProcessNativeEvent(const inotify_event& inevt)
	214	{
	215	wxLogTrace(wxTRACE_FSWATCHER, InotifyEventToString(inevt));
	216
	217	// after removing inotify watch we get IN_IGNORED for it, but the watch
	218	// will be already removed from our list at that time
	219	if (inevt.mask & IN_IGNORED)
	220	{
	221	return;
	222	}
	223
	224	// get watch entry for this event
	225	wxFSWatchEntryDescriptors::iterator it = m_watchMap.find(inevt.wd);
	226	wxCHECK_RET(it != m_watchMap.end(),
	227	"Watch descriptor not present in the watch map!");
	228
	229	wxFSWatchEntry& watch = *(it->second);
	230	int nativeFlags = inevt.mask;
	231	int flags = Native2WatcherFlags(nativeFlags);
	232
	233	// check out for error/warning condition
	234	if (flags & wxFSW_EVENT_WARNING \|\| flags & wxFSW_EVENT_ERROR)
	235	{
	236	wxString errMsg = GetErrorDescription(Watcher2NativeFlags(flags));
	237	wxFileSystemWatcherEvent event(flags, errMsg);
	238	SendEvent(event);
	239	}
	240	// filter out ignored events and those not asked for.
	241	// we never filter out warnings or exceptions
	242	else if ((flags == 0) \|\| !(flags & watch.GetFlags()))
	243	{
	244	return;
	245	}
	246	// renames
	247	else if (nativeFlags & IN_MOVE)
	248	{
	249	wxInotifyCookies::iterator it = m_cookies.find(inevt.cookie);
	250	if ( it == m_cookies.end() )
	251	{
	252	int size = sizeof(inevt) + inevt.len;
	253	inotify_event* e = (inotify_event*) operator new (size);
	254	memcpy(e, &inevt, size);
	255
	256	wxInotifyCookies::value_type val(e->cookie, e);
	257	m_cookies.insert(val);
	258	}
	259	else
	260	{
	261	inotify_event& oldinevt = *(it->second);
	262
	263	wxFileSystemWatcherEvent event(flags);
	264	if ( inevt.mask & IN_MOVED_FROM )
	265	{
	266	event.SetPath(GetEventPath(watch, inevt));
	267	event.SetNewPath(GetEventPath(watch, oldinevt));
	268	}
	269	else
	270	{
	271	event.SetPath(GetEventPath(watch, oldinevt));
	272	event.SetNewPath(GetEventPath(watch, inevt));
	273	}
	274	SendEvent(event);
275
276	m_cookies.erase(it);
277	delete &oldinevt;
278	}
279	}
280	// every other kind of event
281	else
282	{
283	wxFileName path = GetEventPath(watch, inevt);
284	wxFileSystemWatcherEvent event(flags, path, path);
285	SendEvent(event);
286	}
287	}
288
289	void ProcessRenames()
290	{
291	wxInotifyCookies::iterator it = m_cookies.begin();
292	while ( it != m_cookies.end() )
293	{
294	inotify_event& inevt = *(it->second);
295
296	wxLogTrace(wxTRACE_FSWATCHER, "Processing pending rename events");
297	wxLogTrace(wxTRACE_FSWATCHER, InotifyEventToString(inevt));
298
299	// get watch entry for this event
300	wxFSWatchEntryDescriptors::iterator wit = m_watchMap.find(inevt.wd);
301	wxCHECK_RET(wit != m_watchMap.end(),
302	"Watch descriptor not present in the watch map!");
303
304	wxFSWatchEntry& watch = *(wit->second);
305	int flags = Native2WatcherFlags(inevt.mask);
306	wxFileName path = GetEventPath(watch, inevt);
307	wxFileSystemWatcherEvent event(flags, path, path);
308	SendEvent(event);
309
310	m_cookies.erase(it);
311	delete &inevt;
312	it = m_cookies.begin();
313	}
314	}
315
316	void SendEvent(wxFileSystemWatcherEvent& evt)
317	{
318	wxLogTrace(wxTRACE_FSWATCHER, evt.ToString());
319	m_watcher->GetOwner()->ProcessEvent(evt);
320	}
321
322	int ReadEventsToBuf(char* buf, int size)
323	{
324	wxCHECK_MSG( IsOk(), false,
325	"Inotify not initialized or invalid inotify descriptor" );
326
327	memset(buf, 0, size);
5cd99866	328	ssize_t left = read(m_ifd, buf, size);
6b8ef0b3 VZ	329	if (left == -1)
	330	{
	331	wxLogSysError(_("Unable to read from inotify descriptor"));
	332	return -1;
	333	}
	334	else if (left == 0)
	335	{
	336	wxLogWarning(_("EOF while reading from inotify descriptor"));
	337	return -1;
	338	}
	339
	340	return left;
	341	}
	342
	343	static wxString InotifyEventToString(const inotify_event& inevt)
	344	{
	345	wxString mask = (inevt.mask & IN_ISDIR) ?
	346	wxString::Format("IS_DIR \| %u", inevt.mask & ~IN_ISDIR) :
	347	wxString::Format("%u", inevt.mask);
	348	return wxString::Format("Event: wd=%d, mask=%s, cookie=%u, len=%u, "
	349	"name=%s", inevt.wd, mask, inevt.cookie,
	350	inevt.len, inevt.name);
	351	}
	352
	353	static wxFileName GetEventPath(const wxFSWatchEntry& watch,
	354	const inotify_event& inevt)
	355	{
	356	// only when dir is watched, we have non-empty e.name
	357	wxFileName path = watch.GetPath();
	358	if (path.IsDir())
	359	{
	360	path = wxFileName(path.GetPath(), inevt.name);
	361	}
	362	return path;
	363	}
	364
	365	static int Watcher2NativeFlags(int WXUNUSED(flags))
	366	{
	367	// TODO: it would be nice to subscribe only to the events we really need
	368	return IN_ALL_EVENTS;
	369	}
	370
	371	static int Native2WatcherFlags(int flags)
	372	{
	373	static const int flag_mapping[][2] = {
	374	{ IN_ACCESS, wxFSW_EVENT_ACCESS }, // generated during read!
	375	{ IN_MODIFY, wxFSW_EVENT_MODIFY },
	376	{ IN_ATTRIB, 0 },
	377	{ IN_CLOSE_WRITE, 0 },
	378	{ IN_CLOSE_NOWRITE, 0 },
	379	{ IN_OPEN, 0 },
	380	{ IN_MOVED_FROM, wxFSW_EVENT_RENAME },
	381	{ IN_MOVED_TO, wxFSW_EVENT_RENAME },
	382	{ IN_CREATE, wxFSW_EVENT_CREATE },
	383	{ IN_DELETE, wxFSW_EVENT_DELETE },
	384	{ IN_DELETE_SELF, wxFSW_EVENT_DELETE },
	385	{ IN_MOVE_SELF, wxFSW_EVENT_DELETE },
	386
	387	{ IN_UNMOUNT, wxFSW_EVENT_ERROR },
	388	{ IN_Q_OVERFLOW, wxFSW_EVENT_WARNING},
	389
	390	// ignored, because this is genereted mainly by watcher::Remove()
	391	{ IN_IGNORED, 0 }
	392	};
393
394	unsigned int i=0;
395	for ( ; i < WXSIZEOF(flag_mapping); ++i) {
396	// in this mapping multiple flags at once don't happen
397	if (flags & flag_mapping[i][0])
398	return flag_mapping[i][1];
399	}
400
401	// never reached
402	wxFAIL_MSG(wxString::Format("Unknown inotify event mask %u", flags));
403	return -1;
404	}
405
406	/**
407	* Returns error description for specified inotify mask
408	*/
409	static const wxString GetErrorDescription(int flag)
410	{
411	switch ( flag )
412	{
413	case IN_UNMOUNT:
414	return _("File system containing watched object was unmounted");
415	case IN_Q_OVERFLOW:
416	return _("Event queue overflowed");
417	}
418
419	// never reached
420	wxFAIL_MSG(wxString::Format("Unknown inotify event mask %u", flag));
421	return wxEmptyString;
422	}
423
424	wxFSWSourceHandler* m_handler; // handler for inotify event source
425	wxFSWatchEntryDescriptors m_watchMap; // inotify wd=>wxFSWatchEntry* map
426	wxInotifyCookies m_cookies; // map to track renames
5cd99866 VZ	427	wxEventLoopSource* m_source; // our event loop source
	428
	429	// file descriptor created by inotify_init()
	430	int m_ifd;
6b8ef0b3 VZ	431	};
	432
	433
	434	// ============================================================================
	435	// wxFSWSourceHandler implementation
	436	// ============================================================================
	437
	438	// once we get signaled to read, actuall event reading occurs
	439	void wxFSWSourceHandler::OnReadWaiting()
	440	{
	441	wxLogTrace(wxTRACE_FSWATCHER, "--- OnReadWaiting ---");
	442	m_service->ReadEvents();
	443	}
	444
	445	void wxFSWSourceHandler::OnWriteWaiting()
	446	{
	447	wxFAIL_MSG("We never write to inotify descriptor.");
	448	}
	449
	450	void wxFSWSourceHandler::OnExceptionWaiting()
	451	{
	452	wxFAIL_MSG("We never receive exceptions on inotify descriptor.");
	453	}
	454
	455
	456	// ============================================================================
	457	// wxInotifyFileSystemWatcher implementation
	458	// ============================================================================
	459
	460	wxInotifyFileSystemWatcher::wxInotifyFileSystemWatcher()
	461	: wxFileSystemWatcherBase()
	462	{
	463	Init();
	464	}
	465
	466	wxInotifyFileSystemWatcher::wxInotifyFileSystemWatcher(const wxFileName& path,
	467	int events)
	468	: wxFileSystemWatcherBase()
	469	{
	470	if (!Init())
	471	{
	472	if (m_service)
	473	delete m_service;
	474	return;
	475	}
	476
	477	Add(path, events);
	478	}
	479
	480	wxInotifyFileSystemWatcher::~wxInotifyFileSystemWatcher()
	481	{
	482	}
	483
	484	bool wxInotifyFileSystemWatcher::Init()
	485	{
	486	m_service = new wxFSWatcherImplUnix(this);
	487	return m_service->Init();
	488	}
	489
	490	#endif // wxHAS_INOTIFY
	491
	492	#endif // wxUSE_FSWATCHER