Inotify.cpp

#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include<stdio.h>
#include <deque>
#include<sys/select.h>
#include<sys/time.h>
#include <stdlib.h>
#include<string.h>
#include<fcntl.h>
#include "Initialize.h"
#include "Inotify.h"
#include"main.h"

//最大缓冲数量
#define MAX_BUF_SIZE 5120
bool printEvent(inotify_event *e);
int flag; //store inotify resource descriptor status;
struct timeval tv;
fd_set rfds;
extern int debug_level;
extern int IN_SYNC;
using namespace std;
std::vector<ptrRegex> Inotify::pattern;
int Inotify::m_first_add_watch = 1;

Inotify::Inotify(string rootPath) {
 //初始化正则表达式对象
 Inotify::InitReguar();
 m_fd = inotify_init();
 m_watch = rootPath; //do not have the '/' tail;
 AddWatch(rootPath);
 m_first_add_watch = 0;
 flag = fcntl(m_fd, F_GETFL, 0);
 tv.tv_sec = 0;
 tv.tv_usec = 500000;
 FD_ZERO(&rfds);
 FD_SET(m_fd, &rfds);
}

//=======================================================================
//函数名： InitReguar
//作者： zy(zhoukunta@qq.com)
//日期： 2009-04-05
//功能： 初始化正则表达式对象
//输入参数：无
//返回值： 无
//修改记录：
//=======================================================================

void* Inotify::InitReguar() {
 for (int i = 0; i < Initialize::filter.size(); i++) {
 try {
 ptrRegex tmp(new boost::regex((Initialize::filter[i])));
 pattern.push_back(tmp);
 } catch (boost::regex_error& e) {
 cout << endl << "filter 中" << Initialize::filter[i] << "regular expression error,filter fail" << endl;
 cout << "error content:\t" << e.what() << endl;
 continue;
 }
 }
}

int Inotify::inotify_read_times = 3;

unsigned int Inotify::GetEvents(ptrQFilter q) {
 int times = 1;
 int again = ReadFill(q);
 fcntl(m_fd, F_SETFL, flag | O_NONBLOCK);
 while (again && (times < inotify_read_times)) {
 FD_ZERO(&rfds);
 FD_SET(m_fd, &rfds);
 int retval = select(m_fd + 1, &rfds, NULL, NULL, &tv);
 if (retval) again = ReadFill(q);
 times++;
 }
 fcntl(m_fd, F_SETFL, flag);
 return 1;
}
//=======================================================================
//function name： ReadFill
//author： zy(zhoukunta@qq.com)
//date： 2009-01-24
//function： 将读到的一个或多个inotify事件填入队列
//imput params：q(ptrQFilter)队列的指针对象
//
//return： true有事件填入 false无事件填入
//=======================================================================

bool Inotify::ReadFill(ptrQFilter q) {
 int len = 0;
 char buffer[MAX_BUF_SIZE];
 char* offset = buffer;
 len = read(m_fd, buffer, MAX_BUF_SIZE); //read May lead to this programme blocking
 if (len == -1) return false; //inotify queue empty
 while (offset - buffer < len) {
 inotify_event* event = (struct inotify_event*) offset;
 offset += sizeof ( struct inotify_event) +event->len;
 if (Initialize::debug == true) {
 cout << "inotify wd:" << event->wd << "\tname:" << event->name << "\tmask:" << event->mask << endl;
 }
 if (FilterEvent(event)) continue; //if tmp file continue;
 if (!pattern.empty() && FilterExclude(event)) continue; //filter match regular pattern in xml
 if (debug_level & INOTIFY_DEBUG) printEvent(event);
 FillEvent(event, q);
 }
 return true;
}

int Inotify::FillEvent(inotify_event* event, ptrQFilter que) {

 Event tempEvent(new InotifyEvent());
 tempEvent->wd = event->wd;
 tempEvent->path = (m_path[ event->wd ] + "/" + event->name); //sys sometimes produce large ie.wd which we don't add in the wd list
 tempEvent->mask = event->mask;

 if (event->mask & IN_IGNORED) {
 tempEvent->operation = -1;
 return 0;
 } else if ((event->mask & IN_MOVED_FROM) || (event->mask & IN_DELETE)) {
 tempEvent->operation = 0;
 } else if (
 (event->mask & IN_CLOSE_WRITE) ||
 (event->mask & IN_MODIFY) ||
 (event->mask & IN_CREATE) ||
 (event->mask & IN_MOVED_TO)) {
 tempEvent->operation = 1;
 }

 if (event->mask & IN_ISDIR)//remove or delete directory
 {
 tempEvent->dir = true;
 if (tempEvent->operation == 0) //delete folder
 {
 RemoveWatch(tempEvent->path);
 } else if (tempEvent->operation == 1)//create folder add watch
 {
 AddWatch(tempEvent->path);
 }
 } else {
 tempEvent->dir = false;
 }
 //add to rsync queue
 que->push(tempEvent);
 return 1;
}


//=======================================================================
//function name： AddWatch
//author： zy(zhoukunta@qq.com)
//date： 2010-06-02
//function： add the path to inotify api
//input params： path(string) the path need to watch
//return： bool true if success else false
//=======================================================================

bool Inotify::AddWatch(std::string path) {
 int wd = inotify_add_watch(m_fd, path.c_str(), IN_SYNC);
 if (-1 == wd) {
 perror("inotify_add_watch error");
 return false;
 }

 if (Initialize::debug == true) {
 cout << "add watch: " << path << " return wd is: " << wd << endl;
 }

 m_path.insert(PathPair(wd, path));
 DIR* pdir = NULL;
 struct dirent *pfile = NULL;
 if (!(pdir = opendir(path.c_str()))) return false;

 while ((pfile = readdir(pdir))) //read directory content and add recursively
 {
 string pre = path + "/" + pfile->d_name;
 bool is_dir = false;
 if (Initialize::xfs == true) {
 is_dir = IsXfsDir(pre);
 } else {
 is_dir = (pfile->d_type == 4);
 }
 if (is_dir && strcmp(pfile->d_name, ".") && strcmp(pfile->d_name, "..")) {
 if (m_first_add_watch) {
 int length = pre.size() - (m_watch.size() + 1); //relative directory length m_watch+'/'
 string tmp = pre.substr(m_watch.size() + 1, length) + "/";
 boost::cmatch what;
 int filter = 0;
 for (int i = 0; i < pattern.size(); i++) {
 if (boost::regex_match(tmp.c_str(), what, *(pattern[i]))) {
 filter = 1;
 break;
 }
 }
 if (filter) continue;
 }
 AddWatch(pre);
 }
 }
 closedir(pdir);
 return true;
}

bool Inotify::IsXfsDir(std::string path) {
 struct stat sb;
 if (stat(path.c_str(), &sb) == -1) return false;
 return S_ISDIR(sb.st_mode);
}

/*
 *input params: string path not end up with slash /opt/tongbu/temp
 *function: remove the path from watching deque
 *return： success true else false;
 */
bool Inotify::RemoveWatch(std::string path) {
 bool finded = false;
 PathMap::iterator i = m_path.begin();
 for (; i != m_path.end();) {
 if (i->second.empty()) {
 ++i;
 } else if (i->second.substr(0, path.length()) == path) //查找已经添加的监控
 {
 if ((i->second[ path.length() ]) == '/' || i->second[ path.length() ] == 0)//ignore the error /1234/123/ 1234/12/ as the same directory tree
 {
 inotify_rm_watch(m_fd, i->first);
 m_path.erase(i++);
 finded = true; //找到并删除
 } else {
 ++i;
 }
 } else {
 ++i;
 }
 }
 if (!finded) return false;
 return true;
}

//=======================================================================
//函数名： FilterExclude
//作者： zy(zhoukunta@qq.com)
//date： 2009-04-05
//function： filter Exclude path and file
//输入参数：offset(struct inotify_event*)
//
//return： 1该事件需要过滤 0该事件不需过滤
//=======================================================================

int Inotify::FilterExclude(struct inotify_event* offset) {
 int isfilter = 0;
 boost::cmatch what;
 string tmp = m_path[ offset->wd ];
 string pre = "";
 int length;
 if ((length = (tmp.size() - m_watch.size())) > 0) {
 pre = tmp.substr(m_watch.size(), length);
 pre = pre + "/" + offset->name;
 } else {
 pre = offset->name; //root path
 }
 for (int i = 0; i < pattern.size(); i++) {
 if (boost::regex_match(pre.c_str(), what, *(pattern[i]))) return 1;
 }

 return 0;
}

int Inotify::FilterEvent(struct inotify_event* offset) {
 int isfilter = 0;
 do {
 isfilter = (NULL == offset);
 if (isfilter) break;
 //filter create file Event
 isfilter = (Initialize::createFile == false) && ((offset->mask & IN_ISDIR) == 0) && (offset->mask & IN_CREATE);
 if (isfilter) break;

 isfilter = (Initialize::createFolder == false) && ((offset->mask & IN_ISDIR)) && (offset->mask & IN_CREATE);
 if (isfilter) break;

 isfilter = ((strcmp(offset->name, "4913") == 0) && ((offset->mask & IN_ISDIR) == 0));
 isfilter = isfilter || (strcmp((offset->name), "") == 0);
 if (isfilter) break;

 int length = strlen((offset) ->name);
 isfilter = (((offset->name[ length - 1 ] == '~') || ((offset) ->name[ 0 ] == '.')) && (!(offset->mask & IN_ISDIR)));
 if (isfilter) break;


 isfilter = (0 == offset->wd || 0 == offset->mask);
 if (isfilter) break;

 PathMap::reverse_iterator last = m_path.rbegin();
 isfilter = ((offset->wd) > (last->first));
 if (isfilter) break;

 isfilter = (Initialize::createFile == false) && ((offset->mask & IN_ISDIR) == 0) && (offset->mask & IN_CREATE);
 if (isfilter) break;

 isfilter = (Initialize::createFolder == false) && (offset->mask & IN_ISDIR) && (offset->mask & IN_CREATE);
 if (isfilter) break;

 } while (0);

 return isfilter;
}

bool printEvent(inotify_event *e) {
 if (debug_level & SUB_CLASS) {
 cout << "name: " << e->name << "\t" << "mask: " << e->mask << "\t" << "len: " << e->len << endl;
 }

}