inotify_tree.c

#define _GNU_SOURCE
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <limits.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <errno.h>

typedef struct watch_entry {
    int wd;
    char path[PATH_MAX];
} watch_entry_t;

static watch_entry_t table[1024];
static int tlen = 0;

static void add_watch_entry(int wd, const char *path)
{
    if (tlen >= 1024) return;
    table[tlen].wd = wd;
    strncpy(table[tlen].path, path, sizeof(table[tlen].path) - 1);
    table[tlen].path[sizeof(table[tlen].path) - 1] = 0;
    tlen++;
}

static const char *lookup_path(int wd)
{
    for (int i = 0; i < tlen; i++) {
        if (table[i].wd == wd) return table[i].path;
    }
    return "?";
}

static void add_tree(int fd, const char *root)
{
    int wd = inotify_add_watch(fd, root, IN_CREATE | IN_DELETE | IN_MODIFY | IN_MOVED_FROM | IN_MOVED_TO);
    if (wd >= 0) add_watch_entry(wd, root);
    DIR *d = opendir(root);
    if (!d) return;
    struct dirent *de;
    while ((de = readdir(d)) != NULL) {
        if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
        char path[PATH_MAX];
        snprintf(path, sizeof path, "%s/%s", root, de->d_name);
        struct stat st;
        if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
            add_tree(fd, path);
        }
    }
    closedir(d);
}

int main(int argc, char **argv)
{
#if !defined(__linux__)
    fprintf(stderr, "inotify_tree is Linux-only\n");
    return 1;
#else
    const char *root = argc > 1 ? argv[1] : ".";
    int fd = inotify_init1(IN_NONBLOCK);
    if (fd < 0) {
        perror("inotify_init1");
        return 1;
    }
    add_tree(fd, root);
    printf("watching %s and subdirs\n", root);
    char buf[4096];
    for (;;) {
        ssize_t n = read(fd, buf, sizeof buf);
        if (n < 0) {
            if (errno == EAGAIN || errno == EINTR) {
                usleep(100000);
                continue;
            }
            perror("read");
            break;
        }
        size_t off = 0;
        while (off < (size_t)n) {
            struct inotify_event *ev = (struct inotify_event *)(buf + off);
            const char *base = lookup_path(ev->wd);
            char full[PATH_MAX];
            if (ev->len > 0) snprintf(full, sizeof full, "%s/%s", base, ev->name);
            else snprintf(full, sizeof full, "%s", base);
            printf("event 0x%x on %s\n", ev->mask, full);
            off += sizeof(struct inotify_event) + ev->len;
        }
    }
    close(fd);
    return 0;
#endif
}