Inotify机制的简单应用

编程之路刚刚开始，错误难免，希望大家能够指出。

一、Inotify机制

1.简单介绍inotify：Inotify可用于检测单个文件，也可以检测整个目录。当检测的对象是一个目录的时候，目录本身和目录里的内容都会成为检测的对象。

此种机制的出现的目的是当内核空间发生某种事件之后，可以立即通知到用户空间。方便用户做出具体的操作。

2.inotify的三个API：

　　inotify_init(void)　　　　　　　　　　　　　　　　　　　　　　　　

　　用于创建一个inotify的实例，然后返回inotify事件队列的文件描述符。

　　inotify_add_watch(int fd, const char* pathname, uint32_t  mask)　　

　　该函数用于添加“watch list”，也就是检测列表。 可以是一个新的watch，也可以是一个已经存在的watch。其中fd就是inotify_init的返回值，pathname是要检测目录或者文件的路径，mask就是要检测的事件类型。该函数成功返回的是一个unique的watch描述符。

　　inotify_rm_watch(int fd, int wd)　　　　　　　　　　　　　　　　　   

　　用于从watch list种移除检测的对象。

3.读取事件：

　　使用read系统调用可以获取至少一个（必定为整数个，当剩余空间不足容纳下一个结构体时，该结构体只能下次read获取）的inotify_event结构体。

struct inotify_event {  
    int      wd;           /*watch描述符 */  
    uint32_t mask;     /*  事件掩码 */  
    uint32_t cookie;   
    uint32_t len;      /* name的长度 */  
    char     name[];   /* 文件或目录名 */  
};  

　　切记如果read()的读取缓冲区如果小于一个inotify_event的长度，read会返回错误，所以建议缓冲区为每个inotify_event的长度假定为“sizeof(struct inotify_event) + NAME_MAX +1”，“NAME_MAX”是系统文件名最大长度的宏定义。

二、sigaction 函数

1.int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)　　　　　　这个系统调用的作用是改变进程接收到的指定信号的行动。

　　signum : 说明具体信号，它可以是除了SIGKILL和SIGSTOP之外的任何有效信号值。

　　act : 将要安装的signum定义信号的新行动。

　　oldact: 用来保存signum定义信号的过去的行动。

2.目前个人所了解的sigaction和signal的区别：

　　1.signal只能对信号进行一次自定义处理，之后恢复默认操作，sigaction可以进行反复调用；

　　2.signal处理过程中无法阻塞某些信号，而sigaction可以阻塞它自身和其他信号；

3.sigaction 结构体定义如下：

struct sigaction {

    void (*sa_handler)(int);    设置为SIG_DFL表示默认行动，设置为SIG_IGN表示忽略这个信号，或者设置为处理函数的指针。

    void (*sa_sigaction)(int,  siginfo_t* , vid*);

    sigset_t sa_mask;    这个参数指明了在信号处理函数执行过程中应该被阻止的信号的mask值(包括它自己)。

    int sa_flags;   改变信号的行为；

    void (*sa_restorer)(void);

};

简单说明一下思路：
　　1.将argv[1]指定的目录及其子目录都设置为受监控目录；

　　2.不断去read事件，并将事件指定记录在某个文件内，并存有时间发生的大概时间；

　　3.进程需要通过发送“SIGINT”信号来进行停止。

#define _XOPEN_SOURCE 500

#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/inotify.h>
#include <limits.h>
#include <fcntl.h>
#include <ftw.h>
#include <time.h>

#define BUF_SIZE (10 *(sizeof(struct inotify_event) + NAME_MAX +1))
#define INOTIFT_EVENT (IN_CREATE | IN_DELETE | IN_DELETE_SELF | IN_MODIFY | IN_MOVED_FROM | IN_MOVED_TO)

struct pathInfo
{
    int wd;
    char czPath[256];
    struct pathInfo *pNext;
};

struct eventInfo
{
    int event;
    char explain[30];
};

static struct eventInfo g_stEventInfo[] =
{
    {IN_CREATE,"create file"},
    {IN_DELETE,"delete file"},
    {IN_DELETE_SELF,"delete file"},
    {IN_MODIFY,"alter file"},
    {IN_MOVED_FROM,"lose file"},
    {IN_MOVED_TO,"append file"},
};

int g_inotifyFd;
FILE *g_fp;
struct pathInfo *g_list;

/*
IN_CREATE               在受监控目录下创建了文件或目录
IN_DELETE               在受监控目录内删除了文件或目录
IN_DELETE_SELF          删除了受监控目录/文件本身
IN_MODIFY               文件被修改
IN_MOVED_FROM           文件移除受监控目录
IN_MOVED_TO             将文件移到受监控目录
*/

int myNfwt(const char *fpath,const struct stat *sb,int flag,struct FTW *ftwbuf)
{
    if(flag != FTW_DP)
    {
        return 0;
    }
    int wd = inotify_add_watch(g_inotifyFd,fpath,INOTIFT_EVENT);
    if(wd == -1)
    {
        perror("inotify_add_watch");
        return -1;
    }

    struct pathInfo *pTemp = (struct pathInfo *)malloc(sizeof(struct pathInfo));
    memset(pTemp->czPath,0,sizeof(pTemp->czPath));
    pTemp->wd = wd;
    pTemp->pNext = NULL;
    if(strcpy(pTemp->czPath,fpath) == NULL)
    {
        perror("strcpy");
        return -2;
    }

    if(g_list == NULL)
    {
        g_list = pTemp;
        return 0;
    }
    else
    {
        if(g_list->pNext == NULL)
        {
            g_list->pNext = pTemp;
            return 0;
        }
        struct pathInfo *p = g_list->pNext;
        while(1)
        {
            if(p->pNext == NULL)
            {
                p->pNext = pTemp;
                return 0;
            }
            p = p->pNext;
        }
    }
}

int watch_object(char *fileName)
{
    int flags = FTW_PHYS | FTW_DEPTH;
    int ret = nftw(fileName,myNfwt,896,flags);
    if(ret == -1)
    {
        perror("nftw");
        return -1;
    }

    return 0;
}

char *GetPath(int wd)
{
    if(g_list == NULL)
    {
        return NULL;
    }
    if(g_list->wd == wd)
    {
        return g_list->czPath;
    }
    struct pathInfo *pTemp = g_list->pNext;

    while(1)
    {
        if(pTemp == NULL)
        {
            break;
        }
        if(pTemp->wd == wd)
        {
            return pTemp->czPath;
        }
        pTemp = pTemp->pNext;
    }
    return NULL;
}

int recordEvent()
{
    int iReadNum;
    char czBuf[BUF_SIZE+1] = {0};
    struct inotify_event *pEvent;
    time_t now;
    struct tm*tm_now;

    iReadNum = read(g_inotifyFd,czBuf,BUF_SIZE);
    if(iReadNum == -1)
    {
        printf("read failed
");
        return -4;
    }
    else if(iReadNum == 0)
    {
        return 0;
    }
    time(&now);
    tm_now = localtime(&now);
    char *p = czBuf;
    while(1)
    {
        if(p >= czBuf+iReadNum)
        {
            break;
        }
        pEvent = (struct inotify_event *)p;
        char *pPath = GetPath(pEvent->wd);
        if(pPath == NULL)
        {
            return -5;
        }
        for(int index = 0;index < sizeof(g_stEventInfo)/sizeof(struct eventInfo);index++)
        {
            if(pEvent->mask & (g_stEventInfo[index].event))
            {
                fprintf(g_fp,"path : %-30s	   event : %-30s	   file name : %-30s	   time : %s",pPath,g_stEventInfo[index].explain,pEvent->name,asctime(tm_now));
                break;
            }
        }
        fflush(g_fp);
        p += (sizeof(struct inotify_event) + pEvent->len);
    }

    return 0;
}

int GetFileLine()
{
    char *p;
    char czBuf[200] = {0};
    int line = 0;
    while(1)
    {
        p = fgets(czBuf,200,g_fp);
        if(p == NULL)
        {
            return line;
        }
        line++;
    }
    return -1;
}

int freeSpace(struct pathInfo **pInfo)
{
    if(*pInfo == NULL)
    {
        return 0;
    }
    else
    {
        if((*pInfo)->pNext == NULL)
        {
            if(inotify_rm_watch(g_inotifyFd,(*pInfo)->wd) == -1)
            {
                printf("notify_rm_watch error
");
            }
            free((*pInfo));
            *pInfo = NULL;
            return 0;
        }
        else
        {
            freeSpace(&((*pInfo)->pNext));
            if(inotify_rm_watch(g_inotifyFd,(*pInfo)->wd) == -1)
            {
                printf("notify_rm_watch error
");
            }
            free(*pInfo);
            *pInfo = NULL;
            return 0;
        }
    }
    return -1;
}


void catch_signal(int sig)
{
    if(sig == SIGINT)
    {
        int ret = freeSpace(&g_list);
        if(ret < 0)
        {
            printf("free space failed
");
        }
        close(g_inotifyFd);
        fclose(g_fp);
    }
}

int main(int argc,char *argv[])
{
    if(argc < 2)
    {
        printf("please input file/dir name:./a.ot File.txt
");
        return -1;
    }

    g_inotifyFd = inotify_init();
    if(g_inotifyFd == -1)
    {
        perror("inotify_init");
        return -2;
    }
    int ret = watch_object(argv[1]);
    if(ret != 0)
    {
        return -3;
    }

    g_fp = fopen("/home/gc/Record_Jyb","a+");
    if(g_fp == NULL)
    {
        perror("fopen");
        return -4;
    }

    struct sigaction stSign;
    stSign.sa_handler = catch_signal;
    sigemptyset(&stSign.sa_mask);
    stSign.sa_flags = SA_RESETHAND;
    sigaction(SIGINT,&stSign,0);

    while(1)
    {
        if(GetFileLine() >= 1000)
        {
            fclose(g_fp);
            g_fp = fopen("/home/gc/Record_Jyb","w");
            if(g_fp == NULL)
            {
                perror("fopen");
                return -5;
            }
            fclose(g_fp);
            g_fp = fopen("/home/gc/Record_Jyb","a+");
            if(g_fp == NULL)
            {
                perror("fopen");
                return -6;
            }
        }
        ret = recordEvent();
        if(ret < 0)
        {
            return -5;
        }
        sleep(10);
    }
}

总的来说，虽然这只是一个很简单的功能，但还是为自己的一小步提升而高兴，在此分享给各位一起进步。

单单代码逻辑可修改的地方就有很多，还望大家见谅。