inotify-cxx.h

Go to the documentation of this file.

#ifndef _INOTIFYCXX_H_
#define _INOTIFYCXX_H_

#include <stdint.h>
#include <string>
#include <deque>
#include <map>

// Please ensure that the following headers take the right place
#include <sys/syscall.h>
#include <sys/inotify.h>

// Use this if syscalls not defined
#ifndef __NR_inotify_init
#include <sys/inotify-syscalls.h>
#endif // __NR_inotify_init

#define INOTIFY_EVENT_SIZE (sizeof(struct inotify_event))

#define INOTIFY_BUFLEN (1024 * (INOTIFY_EVENT_SIZE + 16))


#define IN_EXC_MSG(msg) (std::string(__PRETTY_FUNCTION__) + ": " + msg)

typedef enum
{
  IN_MAX_EVENTS     = 0,  
  IN_MAX_INSTANCES  = 1,  
  IN_MAX_WATCHES    = 2   
} InotifyCapability_t;


#ifdef INOTIFY_THREAD_SAFE

#include <pthread.h>

#define IN_LOCK_DECL mutable pthread_rwlock_t __m_lock;

#define IN_LOCK_INIT \
  { \
    pthread_rwlockattr_t attr; \
    int res = 0; \
    if ((res = pthread_rwlockattr_init(&attr)) != 0) \
      throw InotifyException(IN_EXC_MSG("cannot initialize lock attributes"), res, this); \
    if ((res = pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP)) != 0) \
      throw InotifyException(IN_EXC_MSG("cannot set lock kind"), res, this); \
    if ((res = pthread_rwlock_init(&__m_lock, &attr)) != 0) \
      throw InotifyException(IN_EXC_MSG("cannot initialize lock"), res, this); \
    pthread_rwlockattr_destroy(&attr); \
  }
 
#define IN_LOCK_DONE pthread_rwlock_destroy(&__m_lock);

#define IN_READ_BEGIN \
  { \
    int res = pthread_rwlock_rdlock(&__m_lock); \
    if (res != 0) \
      throw InotifyException(IN_EXC_MSG("locking for reading failed"), res, (void*) this); \
  }
  
#define IN_READ_END \
  { \
    int res = pthread_rwlock_unlock(&__m_lock); \
    if (res != 0) \
      throw InotifyException(IN_EXC_MSG("unlocking failed"), res, (void*) this); \
  }
  
#define IN_READ_END_NOTHROW pthread_rwlock_unlock(&__m_lock);
  
#define IN_WRITE_BEGIN \
  { \
    int res = pthread_rwlock_wrlock(&__m_lock); \
    if (res != 0) \
      throw InotifyException(IN_EXC_MSG("locking for writing failed"), res, (void*) this); \
  }
  
#define IN_WRITE_END IN_READ_END
#define IN_WRITE_END_NOTHROW IN_READ_END_NOTHROW

#else // INOTIFY_THREAD_SAFE

#define IN_LOCK_DECL
#define IN_LOCK_INIT
#define IN_LOCK_DONE
#define IN_READ_BEGIN
#define IN_READ_END
#define IN_READ_END_NOTHROW
#define IN_WRITE_BEGIN
#define IN_WRITE_END
#define IN_WRITE_END_NOTHROW

#endif // INOTIFY_THREAD_SAFE




// forward declaration
class InotifyWatch;
class Inotify;



class InotifyException
{
public:

  InotifyException(const std::string& rMsg = "", int iErr = 0, void* pSrc = NULL)
  : m_msg(rMsg),
    m_err(iErr)
  {
    m_pSrc = pSrc;
  }
  

  inline const std::string& GetMessage() const
  {
    return m_msg;
  }
  

  inline int GetErrorNumber() const
  {
    return m_err;
  } 
  

  inline void* GetSource() const
  {
    return m_pSrc;
  }

protected:
  std::string m_msg;      
  int m_err;              
  mutable void* m_pSrc;   
};



class InotifyEvent
{
public:

  InotifyEvent()
  : m_uMask(0),
    m_uCookie(0)
  {
    m_pWatch = NULL;
  }
  

  InotifyEvent(const struct inotify_event* pEvt, InotifyWatch* pWatch)
  : m_uMask(0),
    m_uCookie(0)
  {
    if (pEvt != NULL) {
      m_uMask = (uint32_t) pEvt->mask;
      m_uCookie = (uint32_t) pEvt->cookie;
      if (pEvt->name != NULL) {
        m_name = pEvt->len > 0
            ? pEvt->name
            : "";
      }
      m_pWatch = pWatch;
    }
    else {
      m_pWatch = NULL;
    }
  }
  
  ~InotifyEvent() {}
  

  int32_t GetDescriptor() const;
  

  inline uint32_t GetMask() const
  {
    return m_uMask;
  }
  

  inline static bool IsType(uint32_t uValue, uint32_t uType)
  {
    return ((uValue & uType) != 0) && ((~uValue & uType) == 0);
  }
  

  inline bool IsType(uint32_t uType) const
  {
    return IsType(m_uMask, uType);
  }
  

  inline uint32_t GetCookie() const
  {
    return m_uCookie;
  }
  

  inline uint32_t GetLength() const
  {
    return (uint32_t) m_name.length();
  }
  

  inline const std::string& GetName() const
  {
    return m_name;
  }
  

  inline void GetName(std::string& rName) const
  {
    rName = GetName();
  }
  

  inline InotifyWatch* GetWatch()
  {
    return m_pWatch;
  }
  

  static uint32_t GetMaskByName(const std::string& rName);
  

  static void DumpTypes(uint32_t uValue, std::string& rStr);
  

  void DumpTypes(std::string& rStr) const;
  
private:
  uint32_t m_uMask;           
  uint32_t m_uCookie;         
  std::string m_name;         
  InotifyWatch* m_pWatch;     
};




class InotifyWatch
{
public:

  InotifyWatch(const std::string& rPath, int32_t uMask, bool fEnabled = true)
  : m_path(rPath),
    m_uMask(uMask),
    m_wd((int32_t) -1),
    m_fEnabled(fEnabled)
  {
    IN_LOCK_INIT
  }
  
  ~InotifyWatch()
  {
    IN_LOCK_DONE
  }
  

  inline int32_t GetDescriptor() const
  {
    return m_wd;
  }
  

  inline const std::string& GetPath() const
  {
    return m_path;
  }
  

  inline uint32_t GetMask() const
  {
    return (uint32_t) m_uMask;
  }
  

  void SetMask(uint32_t uMask) throw (InotifyException);   
  

  inline Inotify* GetInotify()
  {
    return m_pInotify;
  }
  

  void SetEnabled(bool fEnabled) throw (InotifyException);
  

  inline bool IsEnabled() const
  {
    return m_fEnabled;
  }
  

  inline bool IsRecursive() const
  {
    return false;    
  }
  
private:
  friend class Inotify;

  std::string m_path;   
  uint32_t m_uMask;     
  int32_t m_wd;         
  Inotify* m_pInotify;  
  bool m_fEnabled;      
  
  IN_LOCK_DECL
  

  void __Disable();
};


typedef std::map<int32_t, InotifyWatch*> IN_WATCH_MAP;

typedef std::map<std::string, InotifyWatch*> IN_WP_MAP;



class Inotify
{
public:

  Inotify() throw (InotifyException);
  

  ~Inotify();
  
  void Close();
    

  void Add(InotifyWatch* pWatch) throw (InotifyException);
  

  inline void Add(InotifyWatch& rWatch) throw (InotifyException)
  {
    Add(&rWatch);
  }
  

  void Remove(InotifyWatch* pWatch) throw (InotifyException);
  

  inline void Remove(InotifyWatch& rWatch) throw (InotifyException)
  {
    Remove(&rWatch);
  }
  
  void RemoveAll();
  

  inline size_t GetWatchCount() const
  {
    IN_READ_BEGIN
    size_t n = (size_t) m_paths.size();
    IN_READ_END
    return n;
  }
  

  inline size_t GetEnabledCount() const
  {
    IN_READ_BEGIN
    size_t n = (size_t) m_watches.size();
    IN_READ_END
    return n;
  }
  

  void WaitForEvents(bool fNoIntr = false) throw (InotifyException);
  

  inline size_t GetEventCount()
  {
    IN_READ_BEGIN
    size_t n = (size_t) m_events.size();
    IN_READ_END
    return n;
  }
  

  bool GetEvent(InotifyEvent* pEvt) throw (InotifyException);
  

  bool GetEvent(InotifyEvent& rEvt) throw (InotifyException)
  {
    return GetEvent(&rEvt);
  }
  

  bool PeekEvent(InotifyEvent* pEvt) throw (InotifyException);
  

  bool PeekEvent(InotifyEvent& rEvt) throw (InotifyException)
  {
    return PeekEvent(&rEvt);
  }
  

  InotifyWatch* FindWatch(int iDescriptor);
  

   InotifyWatch* FindWatch(const std::string& rPath);
  

  inline int GetDescriptor() const
  {
    return m_fd;
  }
  

  void SetNonBlock(bool fNonBlock) throw (InotifyException);
  

  void SetCloseOnExec(bool fClOnEx) throw (InotifyException);
  

  static uint32_t GetCapability(InotifyCapability_t cap) throw (InotifyException);
  

  static void SetCapability(InotifyCapability_t cap, uint32_t val) throw (InotifyException);
  

  inline static uint32_t GetMaxEvents() throw (InotifyException)
  {
    return GetCapability(IN_MAX_EVENTS);
  }
  

  inline static void SetMaxEvents(uint32_t val) throw (InotifyException)
  {
    SetCapability(IN_MAX_EVENTS, val);
  }
  

  inline static uint32_t GetMaxInstances() throw (InotifyException)
  {
    return GetCapability(IN_MAX_INSTANCES);
  }
  

  inline static void SetMaxInstances(uint32_t val) throw (InotifyException)
  {
    SetCapability(IN_MAX_INSTANCES, val);
  }
  

  inline static uint32_t GetMaxWatches() throw (InotifyException)
  {
    return GetCapability(IN_MAX_WATCHES);
  }
  

  inline static void SetMaxWatches(uint32_t val) throw (InotifyException)
  {
    SetCapability(IN_MAX_WATCHES, val);
  }

private: 
  int m_fd;                             
  IN_WATCH_MAP m_watches;               
  IN_WP_MAP m_paths;                    
  unsigned char m_buf[INOTIFY_BUFLEN];  
  std::deque<InotifyEvent> m_events;    
  
  IN_LOCK_DECL
  
  friend class InotifyWatch;
  
  static std::string GetCapabilityPath(InotifyCapability_t cap) throw (InotifyException);
};


#endif //_INOTIFYCXX_H_