Subversion Repositories public

/// inotify C++ interface implementation

/**

 * \file inotify-cxx.cpp

 *

 * inotify C++ interface

 *

 * Copyright (C) 2006, 2007, 2009 Lukas Jelinek <lukas@aiken.cz>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of one of the following licenses:

 *

 * \li 1. X11-style license (see LICENSE-X11)

 * \li 2. GNU Lesser General Public License, version 2.1 (see LICENSE-LGPL)

 * \li 3. GNU General Public License, version 2  (see LICENSE-GPL)

 *

 * If you want to help with choosing the best license for you,

 * please visit http://www.gnu.org/licenses/license-list.html.

 *

 * Credits:

 *     Mike Frysinger (cleanup of includes)

 *

 */

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <fstream>

#include <sys/syscall.h>

// Use this if syscalls not defined

#ifndef __NR_inotify_init

#include <sys/inotify-syscalls.h>

#endif // __NR_inotify_init

#include "inotify-cxx.h"

/// procfs inotify base path

#define PROCFS_INOTIFY_BASE "/proc/sys/fs/inotify/"

/// dump separator (between particular entries)

#define DUMP_SEP \

  ({ \

    if (!rStr.empty()) { \

      rStr.append(","); \

    } \

  })

int32_t InotifyEvent::GetDescriptor() const

{

  return  m_pWatch != NULL            // if watch exists

      ?   m_pWatch->GetDescriptor()   // return its descriptor

      :   -1;                         // else return -1

}

uint32_t InotifyEvent::GetMaskByName(const std::string& rName)

{

  if (rName == "IN_ACCESS")

    return IN_ACCESS;

  else if (rName == "IN_MODIFY")

    return IN_MODIFY;

  else if (rName == "IN_ATTRIB")

    return IN_ATTRIB;

  else if (rName == "IN_CLOSE_WRITE")

    return IN_CLOSE_WRITE;

  else if (rName == "IN_CLOSE_NOWRITE")

    return IN_CLOSE_NOWRITE;

  else if (rName == "IN_OPEN")

    return IN_OPEN;

  else if (rName == "IN_MOVED_FROM")

    return IN_MOVED_FROM;

  else if (rName == "IN_MOVED_TO")

    return IN_MOVED_TO;

  else if (rName == "IN_CREATE")

    return IN_CREATE;

  else if (rName == "IN_DELETE")

    return IN_DELETE;

  else if (rName == "IN_DELETE_SELF")

    return IN_DELETE_SELF;

  else if (rName == "IN_UNMOUNT")

    return IN_UNMOUNT;

  else if (rName == "IN_Q_OVERFLOW")

    return IN_Q_OVERFLOW;

  else if (rName == "IN_IGNORED")

    return IN_IGNORED;

  else if (rName == "IN_CLOSE")

    return IN_CLOSE;

  else if (rName == "IN_MOVE")

    return IN_MOVE;

  else if (rName == "IN_ISDIR")

    return IN_ISDIR;

  else if (rName == "IN_ONESHOT")

    return IN_ONESHOT;

  else if (rName == "IN_ALL_EVENTS")

    return IN_ALL_EVENTS;

#ifdef IN_DONT_FOLLOW

  else if (rName == "IN_DONT_FOLLOW")

    return IN_DONT_FOLLOW;

#endif // IN_DONT_FOLLOW

#ifdef IN_ONLYDIR

  else if (rName == "IN_ONLYDIR")

    return IN_ONLYDIR;

#endif // IN_ONLYDIR

#ifdef IN_MOVE_SELF

  else if (rName == "IN_MOVE_SELF")

    return IN_MOVE_SELF;

#endif // IN_MOVE_SELF

  return (uint32_t) 0;

}

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

{

  rStr = "";

  if (IsType(uValue, IN_ALL_EVENTS)) {

    rStr.append("IN_ALL_EVENTS");

  }

  else {

    if (IsType(uValue, IN_ACCESS)) {

      DUMP_SEP;

      rStr.append("IN_ACCESS");    

    }

    if (IsType(uValue, IN_MODIFY)) {

      DUMP_SEP;

      rStr.append("IN_MODIFY");

    }

    if (IsType(uValue, IN_ATTRIB)) {

      DUMP_SEP;

      rStr.append("IN_ATTRIB");

    }

    if (IsType(uValue, IN_CREATE)) {

      DUMP_SEP;

      rStr.append("IN_CREATE");

    }

    if (IsType(uValue, IN_DELETE)) {

      DUMP_SEP;

      rStr.append("IN_DELETE");

    }

    if (IsType(uValue, IN_DELETE_SELF)) {

      DUMP_SEP;

      rStr.append("IN_DELETE_SELF");

    }

    if (IsType(uValue, IN_OPEN)) {

      DUMP_SEP;

      rStr.append("IN_OPEN");

    }

    if (IsType(uValue, IN_CLOSE)) {

      DUMP_SEP;

      rStr.append("IN_CLOSE");

    }

#ifdef IN_MOVE_SELF

    if (IsType(uValue, IN_MOVE_SELF)) {

      DUMP_SEP;

      rStr.append("IN_MOVE_SELF");    

    }

#endif // IN_MOVE_SELF

    else {

      if (IsType(uValue, IN_CLOSE_WRITE)) {

        DUMP_SEP;

        rStr.append("IN_CLOSE_WRITE");

      }

      if (IsType(uValue, IN_CLOSE_NOWRITE)) {

        DUMP_SEP;

        rStr.append("IN_CLOSE_NOWRITE");

      }

    }

    if (IsType(uValue, IN_MOVE)) {

      DUMP_SEP;

      rStr.append("IN_MOVE");

    }

    else {

      if (IsType(uValue, IN_MOVED_FROM)) {

        DUMP_SEP;

        rStr.append("IN_MOVED_FROM");

      }

      if (IsType(uValue, IN_MOVED_TO)) {

        DUMP_SEP;

        rStr.append("IN_MOVED_TO");

      }

    }

  }

  if (IsType(uValue, IN_UNMOUNT)) {

    DUMP_SEP;

    rStr.append("IN_UNMOUNT");

  }

  if (IsType(uValue, IN_Q_OVERFLOW)) {

    DUMP_SEP;

    rStr.append("IN_Q_OVERFLOW");

  }

  if (IsType(uValue, IN_IGNORED)) {

    DUMP_SEP;

    rStr.append("IN_IGNORED");

  }

  if (IsType(uValue, IN_ISDIR)) {

    DUMP_SEP;

    rStr.append("IN_ISDIR");

  }

  if (IsType(uValue, IN_ONESHOT)) {

    DUMP_SEP;

    rStr.append("IN_ONESHOT");

  }

#ifdef IN_DONT_FOLLOW

  if (IsType(uValue, IN_DONT_FOLLOW)) {

    DUMP_SEP;

    rStr.append("IN_DONT_FOLLOW");

  }

#endif // IN_DONT_FOLLOW

#ifdef IN_ONLYDIR

  if (IsType(uValue, IN_ONLYDIR)) {

    DUMP_SEP;

    rStr.append("IN_ONLYDIR");

  }

#endif // IN_ONLYDIR

}

void InotifyEvent::DumpTypes(std::string& rStr) const

{

  DumpTypes(m_uMask, rStr);

}

void InotifyWatch::SetMask(uint32_t uMask) throw (InotifyException)

{

  IN_WRITE_BEGIN

  if (m_wd != -1) {

    int wd = inotify_add_watch(m_pInotify->GetDescriptor(), m_path.c_str(), uMask);

    if (wd != m_wd) {

      IN_WRITE_END_NOTHROW

      throw InotifyException(IN_EXC_MSG("changing mask failed"), wd == -1 ? errno : EINVAL, this);

    }

  }

  m_uMask = uMask;

  IN_WRITE_END

}

void InotifyWatch::SetEnabled(bool fEnabled) throw (InotifyException)

{

  IN_WRITE_BEGIN

  if (fEnabled == m_fEnabled) {

    IN_WRITE_END_NOTHROW

    return;

  }

  if (m_pInotify != NULL) {

    if (fEnabled) {

      m_wd = inotify_add_watch(m_pInotify->GetDescriptor(), m_path.c_str(), m_uMask);

      if (m_wd == -1) {

        IN_WRITE_END_NOTHROW

        throw InotifyException(IN_EXC_MSG("enabling watch failed"), errno, this);

      }

      m_pInotify->m_watches.insert(IN_WATCH_MAP::value_type(m_wd, this));

    }

    else {

      if (inotify_rm_watch(m_pInotify->GetDescriptor(), m_wd) != 0) {

        IN_WRITE_END_NOTHROW

        throw InotifyException(IN_EXC_MSG("disabling watch failed"), errno, this);

      }

      m_pInotify->m_watches.erase(m_wd);

      m_wd = -1;

    }

  }

  m_fEnabled = fEnabled;

  IN_WRITE_END

}

void InotifyWatch::__Disable()

{

  IN_WRITE_BEGIN

  if (!m_fEnabled) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("event cannot occur on disabled watch"), EINVAL, this);

  }

  if (m_pInotify != NULL) {

    m_pInotify->m_watches.erase(m_wd);

    m_wd = -1;

  }

  m_fEnabled = false;

  IN_WRITE_END

}

Inotify::Inotify() throw (InotifyException)

{

  IN_LOCK_INIT

  m_fd = inotify_init();

  if (m_fd == -1) {

    IN_LOCK_DONE

    throw InotifyException(IN_EXC_MSG("inotify init failed"), errno, NULL);

  }

}

Inotify::~Inotify()

{

  Close();

  IN_LOCK_DONE

}

void Inotify::Close()

{

  IN_WRITE_BEGIN

  if (m_fd != -1) {

    RemoveAll();

    close(m_fd);

    m_fd = -1;

  }

  IN_WRITE_END

}

void Inotify::Add(InotifyWatch* pWatch) throw (InotifyException)

{

  IN_WRITE_BEGIN

  // invalid descriptor - this case shouldn't occur - go away

  if (m_fd == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);

  }

  // this path already watched - go away  

  if (FindWatch(pWatch->GetPath()) != NULL) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("path already watched"), EBUSY, this);

  }

  // for enabled watch

  if (pWatch->IsEnabled()) {

    // try to add watch to kernel

    int wd = inotify_add_watch(m_fd, pWatch->GetPath().c_str(), pWatch->GetMask());

    // adding failed - go away

    if (wd == -1) {

      IN_WRITE_END_NOTHROW

      throw InotifyException(IN_EXC_MSG("adding watch failed"), errno, this);

    }

    // this path already watched (but defined another way)

    InotifyWatch* pW = FindWatch(wd);

    if (pW != NULL) {

      // try to recover old watch because it may be modified - then go away

      if (inotify_add_watch(m_fd, pW->GetPath().c_str(), pW->GetMask()) < 0) {

        IN_WRITE_END_NOTHROW

        throw InotifyException(IN_EXC_MSG("watch collision detected and recovery failed"), errno, this);

      }

      else {

        // recovery failed - go away

        IN_WRITE_END_NOTHROW

        throw InotifyException(IN_EXC_MSG("path already watched (but defined another way)"), EBUSY, this);

      }

    }

    pWatch->m_wd = wd;

    m_watches.insert(IN_WATCH_MAP::value_type(pWatch->m_wd, pWatch));

  }

  m_paths.insert(IN_WP_MAP::value_type(pWatch->m_path, pWatch));

  pWatch->m_pInotify = this;

  IN_WRITE_END

}

void Inotify::Remove(InotifyWatch* pWatch) throw (InotifyException)

{

  IN_WRITE_BEGIN

  // invalid descriptor - this case shouldn't occur - go away

  if (m_fd == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);

  }

  // for enabled watch

  if (pWatch->m_wd != -1) {  

    // removing watch failed - go away

    if (inotify_rm_watch(m_fd, pWatch->m_wd) == -1) {

      IN_WRITE_END_NOTHROW

      throw InotifyException(IN_EXC_MSG("removing watch failed"), errno, this);

    }

    m_watches.erase(pWatch->m_wd);

    pWatch->m_wd = -1;

  }

  m_paths.erase(pWatch->m_path);

  pWatch->m_pInotify = NULL;

  IN_WRITE_END

}

void Inotify::RemoveAll()

{

  IN_WRITE_BEGIN

  IN_WP_MAP::iterator it = m_paths.begin();

  while (it != m_paths.end()) {

    InotifyWatch* pW = (*it).second;

    if (pW->m_wd != -1) {

      inotify_rm_watch(m_fd, pW->m_wd);

      pW->m_wd = -1;

    }

    pW->m_pInotify = NULL;

    it++;

  }

  m_watches.clear();

  m_paths.clear();

  IN_WRITE_END

}

void Inotify::WaitForEvents(bool fNoIntr) throw (InotifyException)

{

  ssize_t len = 0;

  do {

    len = read(m_fd, m_buf, INOTIFY_BUFLEN);

  } while (fNoIntr && len == -1 && errno == EINTR);

  if (len == -1 && !(errno == EWOULDBLOCK || errno == EINTR))

    throw InotifyException(IN_EXC_MSG("reading events failed"), errno, this);

  if (len == -1)

    return;

  IN_WRITE_BEGIN

  ssize_t i = 0;

  while (i < len) {

    struct inotify_event* pEvt = (struct inotify_event*) &m_buf[i];

    InotifyWatch* pW = FindWatch(pEvt->wd);

    if (pW != NULL) {

      InotifyEvent evt(pEvt, pW);

      if (    InotifyEvent::IsType(pW->GetMask(), IN_ONESHOT)

          ||  InotifyEvent::IsType(evt.GetMask(), IN_IGNORED))

        pW->__Disable();

      m_events.push_back(evt);

    }

    i += INOTIFY_EVENT_SIZE + (ssize_t) pEvt->len;

  }

  IN_WRITE_END

}

bool Inotify::GetEvent(InotifyEvent* pEvt) throw (InotifyException)

{

  if (pEvt == NULL)

    throw InotifyException(IN_EXC_MSG("null pointer to event"), EINVAL, this);

  IN_WRITE_BEGIN

  bool b = !m_events.empty();

  if (b) {

    *pEvt = m_events.front();

    m_events.pop_front();

  }

  IN_WRITE_END

  return b;

}

bool Inotify::PeekEvent(InotifyEvent* pEvt) throw (InotifyException)

{

  if (pEvt == NULL)

    throw InotifyException(IN_EXC_MSG("null pointer to event"), EINVAL, this);

  IN_READ_BEGIN

  bool b = !m_events.empty();

  if (b) {

    *pEvt = m_events.front();

  }

  IN_READ_END

  return b;

}

InotifyWatch* Inotify::FindWatch(int iDescriptor)

{

  IN_READ_BEGIN

  IN_WATCH_MAP::iterator it = m_watches.find(iDescriptor);

  InotifyWatch* pW = it == m_watches.end() ? NULL : (*it).second;

  IN_READ_END

  return pW;

}

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

{

  IN_READ_BEGIN

  IN_WP_MAP::iterator it = m_paths.find(rPath);

  InotifyWatch* pW = it == m_paths.end() ? NULL : (*it).second;

  IN_READ_END

  return pW;

}

void Inotify::SetNonBlock(bool fNonBlock) throw (InotifyException)

{

  IN_WRITE_BEGIN

  if (m_fd == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);

  }

  int res = fcntl(m_fd, F_GETFL);

  if (res == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("cannot get inotify flags"), errno, this);

  }

  if (fNonBlock) {

    res |= O_NONBLOCK;

  }

  else {

    res &= ~O_NONBLOCK;

  }

  if (fcntl(m_fd, F_SETFL, res) == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("cannot set inotify flags"), errno, this);

  }

  IN_WRITE_END

}

void Inotify::SetCloseOnExec(bool fClOnEx) throw (InotifyException)

{

  IN_WRITE_BEGIN

  if (m_fd == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("invalid file descriptor"), EBUSY, this);

  }

  int res = fcntl(m_fd, F_GETFD);

  if (res == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("cannot get inotify flags"), errno, this);

  }

  if (fClOnEx) {

    res |= FD_CLOEXEC;

  }

  else {

    res &= ~FD_CLOEXEC;

  }

  if (fcntl(m_fd, F_SETFD, res) == -1) {

    IN_WRITE_END_NOTHROW

    throw InotifyException(IN_EXC_MSG("cannot set inotify flags"), errno, this);

  }

  IN_WRITE_END

}

uint32_t Inotify::GetCapability(InotifyCapability_t cap) throw (InotifyException)

{

  FILE* f = fopen(GetCapabilityPath(cap).c_str(), "r");

  if (f == NULL)

    throw InotifyException(IN_EXC_MSG("cannot get capability"), errno, NULL);

  unsigned int val = 0;

  if (fscanf(f, "%u", &val) != 1) {

    fclose(f);

    throw InotifyException(IN_EXC_MSG("cannot get capability"), EIO, NULL);

  }

  fclose(f);

  return (uint32_t) val;

}

void Inotify::SetCapability(InotifyCapability_t cap, uint32_t val) throw (InotifyException)

{

  FILE* f = fopen(GetCapabilityPath(cap).c_str(), "w");

  if (f == NULL)

    throw InotifyException(IN_EXC_MSG("cannot set capability"), errno, NULL);

  if (fprintf(f, "%u", (unsigned int) val) <= 0) {

    fclose(f);

    throw InotifyException(IN_EXC_MSG("cannot set capability"), EIO, NULL);

  }

  fclose(f);

}

std::string Inotify::GetCapabilityPath(InotifyCapability_t cap) throw (InotifyException)

{

  std::string path(PROCFS_INOTIFY_BASE);

  switch (cap) {

    case IN_MAX_EVENTS:

      path.append("max_queued_events");

      break;

    case IN_MAX_INSTANCES:

      path.append("max_user_instances");

      break;

    case IN_MAX_WATCHES:

      path.append("max_user_watches");

      break;

    default:

      throw InotifyException(IN_EXC_MSG("unknown capability type"), EINVAL, NULL);

  }

  return path;

}