6.1 守护进程课后题2015/8/1

---

题目：编写监控/home/itcast/目录下文件创建与更改的守护进程，日志文件放在/home/itcast/filechangelog

思路：用链表存储文件列表，到下一个周期在用另一个链表存储新的文件列表，然后两个链表对比，找出那些没变，那些是增加的，那些已经删除了，然后根据这些信息把重新把第一个链表修改好，并且把这些信息写到log中去

本程序主要分为5部分，main代码文件，链表函数文件，function函数文件，头文件，Makefile。

main代码文件

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "defend.h"
#include <dirent.h>
#include <stdlib.h>
#include <errno.h>

#define MAX_PATH 1024

struct list *tmp;
int status = 0; //这个是状态位，主要是来验证链表中的文件元素是不是已经被删除

void daemonize(void)
{
    struct list *first; //正常维护的链表
    first = creat_list();   
    struct list *second;    //用来比对文件是否增加或删除的链表
    second = creat_list();

    pid_t pid;
    if ((pid = fork()) < 0)  //创建进程
        sys_err("fork");
    else if(pid != 0)   //父进程挂掉
        exit(0);

    setsid();   //修改自身的会话id

    if(chdir("/") < 0)  //修改运行目录
        sys_err("fork");

    umask(0);   //修改权限掩码
    close(0);   //0,1,2三个文件描述符重定向到NULL
    open("/dev/null", O_RDWR);
    dup2(0, 1);
    dup2(0, 2);

    tmp = first;    //把第一次first的地址给tmp，然后通过load_list函数来加载目录

    load_list("/home/itcast");  //第一次加载目录

    while(1) {
        sleep(600); //运行周期10分钟
        status++;   //更改存在状态位
        tmp = second;   //加载第二遍目录列表，用来和first链表比对
        load_list("/home/itcast"); //加载第二遍
        contrast(first, second); //对比两个链表  
        check_del(first); //把已经删除的文件所对应的first中的链表元素删除
        free_list(second);//释放second的内存，方便下次使用

    }
}

int main(void)
{
    daemonize();    

    return 0;
}

链表函数文件

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
#include "defend.h"

struct list *creat_list()   //创建链表空间
{
    return calloc(sizeof(struct list), 1); 
}

void add_list(struct list *ls, char *name, struct stat *st) //添加链表元素
{
    struct list *p = ls; 
    while(p->next) {
        p = p->next;
    }   
    struct list *tmp = creat_list();
    tmp->next = p->next;
    p->next = tmp;
    strcpy(tmp->name, name);
    memcpy(&tmp->st, st, sizeof(struct stat));
    tmp->status = status%2;
}

void show_list(struct list *ls) //遍历打印链表元素  调试的时候使用
{
    struct list *p = ls;
    while(p) {
        p = p->next;
    }
}

void del_list(struct list *ls, char *name, struct stat *st) //删除链表中特定的元素
{
    struct list *p = ls;
    while(p->next) {
        if((strcmp(p->next->name, name) == 0) && (p->next->st.st_ino == st->st_ino))
            break;
        p = p->next;
    }
    struct list *tmp = p->next;

    if(p->next->next == NULL)
        p->next = NULL;
    else
        p->next  = p->next->next;
    free(tmp);
}

void free_list(struct list *ls) //释放链表
{
    struct list *p = ls->next;
    while(p) {
        struct list *tmp = p->next;
        free(p);
        p = tmp;
    }
    ls->next = NULL;
}

void list_sort(struct list *ls) //链表排序，用过文件的inode号排序，本打算使用别的查找方法，但最终没有实现，暂且放着
{
    struct list *i = ls->next;
    struct list *j = ls->next;
    struct list *tmp = creat_list();

    while(i->next) {
        while(j->next) {
            if(j->st.st_ino > j->next->st.st_ino) {
                strcpy(tmp->name, j->name);
                strcpy(j->name, j->next->name);
                strcpy(j->next->name, tmp->name);

                memcpy(&tmp->st, &j->st, sizeof(struct stat));
                memcpy(&j->st, &j->next->st, sizeof(struct stat));
                memcpy(&j->next->st, &tmp->st, sizeof(struct stat));

                tmp->status = j->status;
                j->status = j->next->status;
                j->next->status = tmp->status;
            }

            j = j->next;
        }
        j = ls->next;
        i = i->next;
    }
    free(tmp);
}

function函数文件

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <errno.h>
#include "defend.h"

#define MAX_PATH 1024

extern struct list *tmp;    //引用外部变量，用于加载链表
extern int status;  //引用外部变量，用于修改文件存在状态

void sys_err(const char *str)
{
    perror(str);
    exit(0);
}

void load_list(char *dir)   //把文件信息加载到链表中去
{
    struct stat st; 

    if(stat(dir,&st) < 0)
        sys_err("stat");

    if((st.st_mode & S_IFMT) == S_IFDIR)
        read_file(dir);

    add_list(tmp, dir, &st);    //加载
}

void read_file(char *file)  //遍历目录中的文件
{
    char name[MAX_PATH];
    struct dirent *read;
    DIR *dir;

    if((dir = opendir(file)) < 0)
        sys_err("opendir");

    while((read = readdir(dir)) != NULL) {
        if(strcmp(read->d_name,".") == 0 || strcmp(read->d_name, "..") == 0)
            continue;
        if(strlen(file) + strlen(read->d_name) + 2 > sizeof(name))
            continue;
        else {
            sprintf(name, "%s/%s", file, read->d_name);
            load_list(name);
    closedir(dir);
}

void contrast(struct list *ls1, struct list *ls2) //对比两个链表元素，如果第二个链表中有，但第一个链表没有的，就增加到第一个链表，并写log
{
    struct list *first = ls1->next;
    struct list *second = ls2->next;

    while (second) {
        if(binary(first, second) != 0) {
            add_list(first, second->name, &second->st);
            write_log(second, "create");
        }
        second = second->next;
    }
}

int  binary(struct list *ls1, const struct list *ls2) //查找链表中有没有这个元素，有就返回0，并更改第一个链表中的status位，没有就返回-1
{
    struct list *first = ls1;

    while(first) {
        if(ls2->st.st_ino == first->st.st_ino) {
                first->status = status%2;
                return 0;
            }
        }
        first = first->next;
    }

    return -1;
}

void check_del(struct list *ls) //检查第一个链表中的status这个字段，来判断文件是否已删除
{
    struct list *p = ls->next;
    while(p->next) {
        if(p->status != status%2) {
            printf("inode = %d, status = %d, name = %s, size = %d\n", (int)p->st.st_ino, p->status,  p->name, (int)p->st.st_size);
            write_log(p, "delete");
            del_list(ls, p->name, &p->st);
        }
        p = p->next;
    }
}

void write_log(struct list *ls, char *buff)  //写日志
{
    int fd;
    time_t t;
    char str[1024] = {0};

    fd = open("/home/itcast/filechangelog", O_CREAT|O_RDWR|O_APPEND, 0664);
    time(&t);
    sprintf(str, "%s\t%s\t%s", buff, ls->name, ctime(&t));
    write(fd, str, strlen(str));
    close(fd);
}

头文件

#define __DEFEND__

struct list {   
    char name[256]; //文件名
    int status; //删除状态位
    struct stat st;     //文件信息
    struct list *next;
};

struct list *creat_list();  //创建

void add_list(struct list *, char *, struct stat *); //添加

void show_list(struct list *); //遍历打印

void del_list(struct list *, char *, struct stat *); //删除元素

void free_list(struct list *); //释放链表

void list_sort(struct list *);  //链表排序

void sys_err(const char *); 

void load_list(char *);     //加载目录

void read_file(char *);     //遍历目录

void contrast(struct list *, struct list *);    //对比两个链表

int  binary(struct list *, const struct list *);    //查找链表中时候存在某个元素

void check_del(struct list *);  //删除文件不存在的元素

void write_log(struct list *ls, char *buff);    //写日志

#endif

问题：

链表中第一个元素为空，只能判断增加或者删除，顺序查找法，效率低下，