inotifytools.c

// kate: replace-tabs off; space-indent off;

#include "../../config.h"
#include "inotifytools/inotifytools.h"
#include "inotifytools_p.h"

#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <dirent.h>
#include <time.h>
#include <regex.h>
#include <setjmp.h>

#include "inotifytools/inotify.h"

#define MAX_EVENTS 4096
#define MAX_STRLEN 4096
#define INOTIFY_PROCDIR "/proc/sys/fs/inotify/"
#define WATCHES_SIZE_PATH INOTIFY_PROCDIR "max_user_watches"
#define QUEUE_SIZE_PATH   INOTIFY_PROCDIR "max_queued_watches"
#define INSTANCES_PATH    INOTIFY_PROCDIR "max_user_instances"

static int inotify_fd;
static unsigned  num_access;
static unsigned  num_modify;
static unsigned  num_attrib;
static unsigned  num_close_nowrite;
static unsigned  num_close_write;
static unsigned  num_open;
static unsigned  num_move_self;
static unsigned  num_moved_to;
static unsigned  num_moved_from;
static unsigned  num_create;
static unsigned  num_delete;
static unsigned  num_delete_self;
static unsigned  num_unmount;
static unsigned  num_total;
static int collect_stats = 0;

struct rbtree *tree_wd = 0;
struct rbtree *tree_filename = 0;
static int error = 0;
static int init = 0;
static char* timefmt = 0;
static regex_t* regex = 0;

int isdir( char const * path );
void record_stats( struct inotify_event const * event );
int onestr_to_event(char const * event);

#define niceassert(cond,mesg) _niceassert((long)cond, __LINE__, __FILE__, \
                                          #cond, mesg)

#define nasprintf(...) niceassert( -1 != asprintf(__VA_ARGS__), "out of memory")

void _niceassert( long cond, int line, char const * file, char const * condstr,
                  char const * mesg ) {
        if ( cond ) return;

        if ( mesg ) {
                fprintf(stderr, "%s:%d assertion ( %s ) failed: %s\n", file, line,
                        condstr, mesg );
        }
        else {
                fprintf(stderr, "%s:%d assertion ( %s ) failed.\n", file, line, condstr);
        }
}

char * chrtostr(char ch) {
        static char str[2] = { '\0', '\0' };
        str[0] = ch;
        return str;
}

int read_num_from_file( char * filename, int * num ) {
        FILE * file = fopen( filename, "r" );
        if ( !file ) {
                error = errno;
                return 0;
        }

        if ( EOF == fscanf( file, "%d", num ) ) {
                error = errno;
                return 0;
        }

        niceassert( 0 == fclose( file ), 0 );

        return 1;
}

int wd_compare(const void *d1, const void *d2, const void *config) {
        if (!d1 || !d2) return d1 - d2;
        return ((watch*)d1)->wd - ((watch*)d2)->wd;
}

int filename_compare(const void *d1, const void *d2, const void *config) {
        if (!d1 || !d2) return d1 - d2;
        return strcmp(((watch*)d1)->filename, ((watch*)d2)->filename);
}

watch *watch_from_wd( int wd ) {
        watch w;
        w.wd = wd;
        return (watch*)rbfind(&w, tree_wd);
}

watch *watch_from_filename( char const *filename ) {
        watch w;
        w.filename = (char*)filename;
        return (watch*)rbfind(&w, tree_filename);
}

int inotifytools_initialize() {
        if (init) return 1;

        error = 0;
        // Try to initialise inotify
        inotify_fd = inotify_init();
        if (inotify_fd < 0)     {
                error = inotify_fd;
                return 0;
        }

        collect_stats = 0;
        init = 1;
        tree_wd = rbinit(wd_compare, 0);
        tree_filename = rbinit(filename_compare, 0);
        timefmt = 0;

        return 1;
}

void destroy_watch(watch *w) {
        if (w->filename) free(w->filename);
        free(w);
}

void cleanup_tree(const void *nodep,
                 const VISIT which,
                 const int depth, void* arg) {
        if (which != endorder && which != leaf) return;
        watch *w = (watch*)nodep;
        destroy_watch(w);
}

void inotifytools_cleanup() {
        if (!init) return;

        init = 0;
        close(inotify_fd);
        collect_stats = 0;
        error = 0;
        timefmt = 0;

        if (regex) {
                regfree(regex);
                free(regex);
                regex = 0;
        }

        rbwalk(tree_wd, cleanup_tree, 0);
        rbdestroy(tree_wd); tree_wd = 0;
        rbdestroy(tree_filename); tree_filename = 0;
}

void empty_stats(const void *nodep,
                 const VISIT which,
                 const int depth, void *arg) {
    if (which != endorder && which != leaf) return;
        watch *w = (watch*)nodep;
        w->hit_access = 0;
        w->hit_modify = 0;
        w->hit_attrib = 0;
        w->hit_close_nowrite = 0;
        w->hit_close_write = 0;
        w->hit_open = 0;
        w->hit_move_self = 0;
        w->hit_moved_from = 0;
        w->hit_moved_to = 0;
        w->hit_create = 0;
        w->hit_delete = 0;
        w->hit_delete_self = 0;
        w->hit_unmount = 0;
        w->hit_total = 0;
}

void replace_filename(const void *nodep,
                      const VISIT which,
                      const int depth, void *arg) {
    if (which != endorder && which != leaf) return;
        watch *w = (watch*)nodep;
        char *old_name = ((char**)arg)[0];
        char *new_name = ((char**)arg)[1];
        int old_len = *((int*)&((char**)arg)[2]);
        char *name;
        if ( 0 == strncmp( old_name, w->filename, old_len ) ) {
                nasprintf( &name, "%s%s", new_name, &(w->filename[old_len]) );
                if (!strcmp( w->filename, new_name )) {
                        free(name);
                } else {
                        rbdelete(w, tree_filename);
                        free( w->filename );
                        w->filename = name;
                        rbsearch(w, tree_filename);
                }
        }
}

void get_num(const void *nodep,
             const VISIT which,
             const int depth, void *arg) {
    if (which != endorder && which != leaf) return;
        ++(*((int*)arg));
}


void inotifytools_initialize_stats() {
        niceassert( init, "inotifytools_initialize not called yet" );

        // if already collecting stats, reset stats
        if (collect_stats) {
                rbwalk(tree_wd, empty_stats, 0);
        }

        num_access = 0;
        num_modify = 0;
        num_attrib = 0;
        num_close_nowrite = 0;
        num_close_write = 0;
        num_open = 0;
        num_move_self = 0;
        num_moved_from = 0;
        num_moved_to = 0;
        num_create = 0;
        num_delete = 0;
        num_delete_self = 0;
        num_unmount = 0;
        num_total = 0;

        collect_stats = 1;
}

int inotifytools_str_to_event_sep(char const * event, char sep) {
        if ( strchr( "_" "abcdefghijklmnopqrstuvwxyz"
                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ", sep ) ) {
                return -1;
        }

        int ret, ret1, len;
        char * event1, * event2;
        char eventstr[4096];
        ret = 0;

        if ( !event || !event[0] ) return 0;

        event1 = (char *)event;
        event2 = strchr( event1, sep );
        while ( event1 && event1[0] ) {
                if ( event2 ) {
                        len = event2 - event1;
                        niceassert( len < 4096, "malformed event string (very long)" );
                }
                else {
                        len = strlen(event1);
                }
                if ( len > 4095 ) len = 4095;
                strncpy( eventstr, event1, len );
                eventstr[len] = 0;

                ret1 = onestr_to_event( eventstr );
                if ( 0 == ret1 || -1 == ret1 ) {
                        ret = ret1;
                        break;
                }
                ret |= ret1;

                event1 = event2;
                if ( event1 && event1[0] ) {
                        // jump over 'sep' character
                        ++event1;
                        // if last character was 'sep'...
                        if ( !event1[0] ) return 0;
                        event2 = strchr( event1, sep );
                }
        }

        return ret;
}

int inotifytools_str_to_event(char const * event) {
        return inotifytools_str_to_event_sep( event, ',' );
}

int onestr_to_event(char const * event)
{
        static int ret;
        ret = -1;

        if ( !event || !event[0] )
                ret = 0;
        else if ( 0 == strcasecmp(event, "ACCESS") )
                ret = IN_ACCESS;
        else if ( 0 == strcasecmp(event, "MODIFY") )
                ret = IN_MODIFY;
        else if ( 0 == strcasecmp(event, "ATTRIB") )
                ret = IN_ATTRIB;
        else if ( 0 == strcasecmp(event, "CLOSE_WRITE") )
                ret = IN_CLOSE_WRITE;
        else if ( 0 == strcasecmp(event, "CLOSE_NOWRITE") )
                ret = IN_CLOSE_NOWRITE;
        else if ( 0 == strcasecmp(event, "OPEN") )
                ret = IN_OPEN;
        else if ( 0 == strcasecmp(event, "MOVED_FROM") )
                ret = IN_MOVED_FROM;
        else if ( 0 == strcasecmp(event, "MOVED_TO") )
                ret = IN_MOVED_TO;
        else if ( 0 == strcasecmp(event, "CREATE") )
                ret = IN_CREATE;
        else if ( 0 == strcasecmp(event, "DELETE") )
                ret = IN_DELETE;
        else if ( 0 == strcasecmp(event, "DELETE_SELF") )
                ret = IN_DELETE_SELF;
        else if ( 0 == strcasecmp(event, "UNMOUNT") )
                ret = IN_UNMOUNT;
        else if ( 0 == strcasecmp(event, "Q_OVERFLOW") )
                ret = IN_Q_OVERFLOW;
        else if ( 0 == strcasecmp(event, "IGNORED") )
                ret = IN_IGNORED;
        else if ( 0 == strcasecmp(event, "CLOSE") )
                ret = IN_CLOSE;
        else if ( 0 == strcasecmp(event, "MOVE_SELF") )
                ret = IN_MOVE_SELF;
        else if ( 0 == strcasecmp(event, "MOVE") )
                ret = IN_MOVE;
        else if ( 0 == strcasecmp(event, "ISDIR") )
                ret = IN_ISDIR;
        else if ( 0 == strcasecmp(event, "ONESHOT") )
                ret = IN_ONESHOT;
        else if ( 0 == strcasecmp(event, "ALL_EVENTS") )
                ret = IN_ALL_EVENTS;

        return ret;
}

char * inotifytools_event_to_str(int events) {
        return inotifytools_event_to_str_sep(events, ',');
}

char * inotifytools_event_to_str_sep(int events, char sep)
{
        static char ret[1024];
        ret[0] = '\0';
        ret[1] = '\0';

        if ( IN_ACCESS & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "ACCESS" );
        }
        if ( IN_MODIFY & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "MODIFY" );
        }
        if ( IN_ATTRIB & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "ATTRIB" );
        }
        if ( IN_CLOSE_WRITE & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "CLOSE_WRITE" );
        }
        if ( IN_CLOSE_NOWRITE & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "CLOSE_NOWRITE" );
        }
        if ( IN_OPEN & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "OPEN" );
        }
        if ( IN_MOVED_FROM & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "MOVED_FROM" );
        }
        if ( IN_MOVED_TO & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "MOVED_TO" );
        }
        if ( IN_CREATE & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "CREATE" );
        }
        if ( IN_DELETE & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "DELETE" );
        }
        if ( IN_DELETE_SELF & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "DELETE_SELF" );
        }
        if ( IN_UNMOUNT & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "UNMOUNT" );
        }
        if ( IN_Q_OVERFLOW & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "Q_OVERFLOW" );
        }
        if ( IN_IGNORED & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "IGNORED" );
        }
        if ( IN_CLOSE & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "CLOSE" );
        }
        if ( IN_MOVE_SELF & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "MOVE_SELF" );
        }
        if ( IN_ISDIR & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "ISDIR" );
        }
        if ( IN_ONESHOT & events ) {
                strcat( ret, chrtostr(sep) );
                strcat( ret, "ONESHOT" );
        }

        // Maybe we didn't match any... ?
        if (ret[0] == '\0') {
                niceassert( -1 != sprintf( ret, "%c0x%08x", sep, events ), 0 );
        }

        return &ret[1];
}

char * inotifytools_filename_from_wd( int wd ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        watch *w = watch_from_wd(wd);
        if (!w) return 0;
        return w->filename;
}

int inotifytools_wd_from_filename( char const * filename ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        watch *w = watch_from_filename(filename);
        if (!w) return -1;
        return w->wd;
}

void inotifytools_set_filename_by_wd( int wd, char const * filename ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        watch *w = watch_from_wd(wd);
        if (!w) return;
        if (w->filename) free(w->filename);
        w->filename = strdup(filename);
}

void inotifytools_set_filename_by_filename( char const * oldname,
                                            char const * newname ) {
        watch *w = watch_from_filename(oldname);
        if (!w) return;
        if (w->filename) free(w->filename);
        w->filename = strdup(newname);
}

void inotifytools_replace_filename( char const * oldname,
                                    char const * newname ) {
        if ( !oldname || !newname ) return;
        char *names[2+sizeof(int)/sizeof(char*)];
        names[0] = (char*)oldname;
        names[1] = (char*)newname;
        *((int*)&names[2]) = strlen(oldname);
        rbwalk(tree_filename, replace_filename, (void*)names);
}

int remove_inotify_watch(watch *w) {
        error = 0;
        int status = inotify_rm_watch( inotify_fd, w->wd );
        if ( status < 0 ) {
                fprintf(stderr, "Failed to remove watch on %s: %s\n", w->filename,
                        strerror(status) );
                error = status;
                return 0;
        }
        return 1;
}

watch *create_watch(int wd, char *filename) {
        if ( wd <= 0 || !filename) return 0;

        watch *w = (watch*)calloc(1, sizeof(watch));
        w->wd = wd;
        w->filename = strdup(filename);
        rbsearch(w, tree_wd);
        rbsearch(w, tree_filename);
        return w;
}

int inotifytools_remove_watch_by_wd( int wd ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        watch *w = watch_from_wd(wd);
        if (!w) return 1;

        if (!remove_inotify_watch(w)) return 0;
        rbdelete(w, tree_wd);
        rbdelete(w, tree_filename);
        destroy_watch(w);
        return 1;
}

int inotifytools_remove_watch_by_filename( char const * filename ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        watch *w = watch_from_filename(filename);
        if (!w) return 1;

        if (!remove_inotify_watch(w)) return 0;
        rbdelete(w, tree_wd);
        rbdelete(w, tree_filename);
        destroy_watch(w);
        return 1;
}

int inotifytools_watch_file( char const * filename, int events ) {
        static char const * filenames[2];
        filenames[0] = filename;
        filenames[1] = NULL;
        return inotifytools_watch_files( filenames, events );
}

int inotifytools_watch_files( char const * filenames[], int events ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        error = 0;

        static int i;
        for ( i = 0; filenames[i]; ++i ) {
                static int wd;
                wd = inotify_add_watch( inotify_fd, filenames[i], events );
                if ( wd < 0 ) {
                        if ( wd == -1 ) {
                                error = errno;
                                return 0;
                        } // if ( wd == -1 )
                        else {
                                fprintf( stderr, "Failed to watch %s: returned wd was %d "
                                         "(expected -1 or >0 )", filenames[i], wd );
                                // no appropriate value for error
                                return 0;
                        } // else
                } // if ( wd < 0 )

                char *filename;
                // Always end filename with / if it is a directory
                if ( !isdir(filenames[i])
                     || filenames[i][strlen(filenames[i])-1] == '/') {
                        filename = strdup(filenames[i]);
                }
                else {
                        nasprintf( &filename, "%s/", filenames[i] );
                }
                create_watch(wd, filename);
                free(filename);
        } // for

        return 1;
}

struct inotify_event * inotifytools_next_event( int timeout ) {
        return inotifytools_next_events( timeout, 1 );
}


struct inotify_event * inotifytools_next_events( int timeout, int num_events ) {
        niceassert( init, "inotifytools_initialize not called yet" );
        niceassert( num_events <= MAX_EVENTS, "too many events requested" );

        if ( num_events < 1 ) return NULL;

        static struct inotify_event event[MAX_EVENTS];
        static struct inotify_event * ret;
        static int first_byte = 0;
        static ssize_t bytes;
        static jmp_buf jmp;
        static char match_name[MAX_STRLEN];

#define RETURN(A) {\
        if (regex) {\
                inotifytools_snprintf(match_name, MAX_STRLEN, A, "%w%f");\
                if (0 == regexec(regex, match_name, 0, 0, 0)) {\
                        longjmp(jmp,0);\
                }\
        }\
        if ( collect_stats ) {\
                record_stats( A );\
        }\
        return A;\
}

        setjmp(jmp);

        error = 0;

        // first_byte is index into event buffer
        if ( first_byte != 0
          && first_byte <= (int)(bytes - sizeof(struct inotify_event)) ) {

                ret = (struct inotify_event *)((char *)&event[0] + first_byte);
                first_byte += sizeof(struct inotify_event) + ret->len;

                // if the pointer to the next event exactly hits end of bytes read,
                // that's good.  next time we're called, we'll read.
                if ( first_byte == bytes ) {
                        first_byte = 0;
                }
                else if ( first_byte > bytes ) {
                        // oh... no.  this can't be happening.  An incomplete event.
                        // Copy what we currently have into first element, call self to
                        // read remainder.
                        // oh, and they BETTER NOT overlap.
                        // Boy I hope this code works.
                        // But I think this can never happen due to how inotify is written.
                        niceassert( (long)((char *)&event[0] +
                                    sizeof(struct inotify_event) +
                                    event[0].len) <= (long)ret,
                                    "extremely unlucky user, death imminent" );
                        // how much of the event do we have?
                        bytes = (char *)&event[0] + bytes - (char *)ret;
                        memcpy( &event[0], ret, bytes );
                        return inotifytools_next_events( timeout, num_events );
                }
                RETURN(ret);

        }

        else if ( first_byte == 0 ) {
                bytes = 0;
        }


        static ssize_t this_bytes;
        static unsigned int bytes_to_read;
        static int rc;
        static fd_set read_fds;

        static struct timeval read_timeout;
        read_timeout.tv_sec = timeout;
        read_timeout.tv_usec = 0;
        static struct timeval * read_timeout_ptr;
        read_timeout_ptr = ( timeout <= 0 ? NULL : &read_timeout );

        FD_ZERO(&read_fds);
        FD_SET(inotify_fd, &read_fds);
        rc = select(inotify_fd + 1, &read_fds,
                    NULL, NULL, read_timeout_ptr);
        if ( rc < 0 ) {
                // error
                error = errno;
                return NULL;
        }
        else if ( rc == 0 ) {
                // timeout
                return NULL;
        }

        // wait until we have enough bytes to read
        do {
                rc = ioctl( inotify_fd, FIONREAD, &bytes_to_read );
        } while ( !rc &&
                  bytes_to_read < sizeof(struct inotify_event)*num_events );

        if ( rc == -1 ) {
                error = errno;
                return NULL;
        }

        this_bytes = read(inotify_fd, &event[0] + bytes,
                          sizeof(struct inotify_event)*MAX_EVENTS - bytes);
        if ( this_bytes < 0 ) {
                error = errno;
                return NULL;
        }
        if ( this_bytes == 0 ) {
                fprintf(stderr, "Inotify reported end-of-file.  Possibly too many "
                                "events occurred at once.\n");
                return NULL;
        }
        bytes += this_bytes;

        ret = &event[0];
        first_byte = sizeof(struct inotify_event) + ret->len;
        niceassert( first_byte <= bytes, "ridiculously long filename, things will "
                                         "almost certainly screw up." );
        if ( first_byte == bytes ) {
                first_byte = 0;
        }

        RETURN(ret);

#undef RETURN
}

int inotifytools_watch_recursively( char const * path, int events ) {
        return inotifytools_watch_recursively_with_exclude( path, events, 0 );
}

int inotifytools_watch_recursively_with_exclude( char const * path, int events,
                                                 char const ** exclude_list ) {
        niceassert( init, "inotifytools_initialize not called yet" );

        DIR * dir;
        char * my_path;
        error = 0;
        dir = opendir( path );
        if ( !dir ) {
                // If not a directory, don't need to do anything special
                if ( errno == ENOTDIR ) {
                        return inotifytools_watch_file( path, events );
                }
                else {
                        error = errno;
                        return 0;
                }
        }

        if ( path[strlen(path)-1] != '/' ) {
                nasprintf( &my_path, "%s/", path );
        }
        else {
                my_path = (char *)path;
        }

        static struct dirent * ent;
        char * next_file;
        static struct stat64 my_stat;
        ent = readdir( dir );
        // Watch each directory within this directory
        while ( ent ) {
                if ( (0 != strcmp( ent->d_name, "." )) &&
                     (0 != strcmp( ent->d_name, ".." )) ) {
                        nasprintf(&next_file,"%s%s", my_path, ent->d_name);
                        if ( -1 == lstat64( next_file, &my_stat ) ) {
                                error = errno;
                                free( next_file );
                                if ( errno != EACCES ) {
                                        error = errno;
                                        if ( my_path != path ) free( my_path );
                                        closedir( dir );
                                        return 0;
                                }
                        }
                        else if ( S_ISDIR( my_stat.st_mode ) &&
                                  !S_ISLNK( my_stat.st_mode )) {
                                free( next_file );
                                nasprintf(&next_file,"%s%s/", my_path, ent->d_name);
                                static unsigned int no_watch;
                                static char const ** exclude_entry;

                                no_watch = 0;
                                for (exclude_entry = exclude_list;
                                         exclude_entry && *exclude_entry && !no_watch;
                                         ++exclude_entry) {
                                        static int exclude_length;

                                        exclude_length = strlen(*exclude_entry);
                                        if ((*exclude_entry)[exclude_length-1] == '/') {
                                                --exclude_length;
                                        }
                                        if ( strlen(next_file) == (unsigned)(exclude_length + 1) &&
                                            !strncmp(*exclude_entry, next_file, exclude_length)) {
                                                // directory found in exclude list
                                                no_watch = 1;
                                        }
                                }
                                if (!no_watch) {
                                        static int status;
                                        status = inotifytools_watch_recursively_with_exclude(
                                                      next_file,
                                                      events,
                                                      exclude_list );
                                        // For some errors, we will continue.
                                        if ( !status && (EACCES != error) && (ENOENT != error) &&
                                             (ELOOP != error) ) {
                                                free( next_file );
                                                if ( my_path != path ) free( my_path );
                                                closedir( dir );
                                                return 0;
                                        }
                                } // if !no_watch
                                free( next_file );
                        } // if isdir and not islnk
                        else {
                                free( next_file );
                        }
                }
                ent = readdir( dir );
                error = 0;
        }

        closedir( dir );

        int ret = inotifytools_watch_file( my_path, events );
        if ( my_path != path ) free( my_path );
        return ret;
}

void record_stats( struct inotify_event const * event ) {
        if (!event) return;
        watch *w = watch_from_wd(event->wd);
        if (!w) return;
        if ( IN_ACCESS & event->mask ) {
                ++w->hit_access;
                ++num_access;
        }
        if ( IN_MODIFY & event->mask ) {
                ++w->hit_modify;
                ++num_modify;
        }
        if ( IN_ATTRIB & event->mask ) {
                ++w->hit_attrib;
                ++num_attrib;
        }
        if ( IN_CLOSE_WRITE & event->mask ) {
                ++w->hit_close_write;
                ++num_close_write;
        }
        if ( IN_CLOSE_NOWRITE & event->mask ) {
                ++w->hit_close_nowrite;
                ++num_close_nowrite;
        }
        if ( IN_OPEN & event->mask ) {
                ++w->hit_open;
                ++num_open;
        }
        if ( IN_MOVED_FROM & event->mask ) {
                ++w->hit_moved_from;
                ++num_moved_from;
        }
        if ( IN_MOVED_TO & event->mask ) {
                ++w->hit_moved_to;
                ++num_moved_to;
        }
        if ( IN_CREATE & event->mask ) {
                ++w->hit_create;
                ++num_create;
        }
        if ( IN_DELETE & event->mask ) {
                ++w->hit_delete;
                ++num_delete;
        }
        if ( IN_DELETE_SELF & event->mask ) {
                ++w->hit_delete_self;
                ++num_delete_self;
        }
        if ( IN_UNMOUNT & event->mask ) {
                ++w->hit_unmount;
                ++num_unmount;
        }
        if ( IN_MOVE_SELF & event->mask ) {
                ++w->hit_move_self;
                ++num_move_self;
        }

        ++w->hit_total;
        ++num_total;

}

int *stat_ptr(watch *w, int event)
{
        if ( IN_ACCESS == event )
                return &w->hit_access;
        if ( IN_MODIFY == event )
                return &w->hit_modify;
        if ( IN_ATTRIB == event )
                return &w->hit_attrib;
        if ( IN_CLOSE_WRITE == event )
                return &w->hit_close_write;
        if ( IN_CLOSE_NOWRITE == event )
                return &w->hit_close_nowrite;
        if ( IN_OPEN == event )
                return &w->hit_open;
        if ( IN_MOVED_FROM == event )
                return &w->hit_moved_from;
        if ( IN_MOVED_TO == event )
                return &w->hit_moved_to;
        if ( IN_CREATE == event )
                return &w->hit_create;
        if ( IN_DELETE == event )
                return &w->hit_delete;
        if ( IN_DELETE_SELF == event )
                return &w->hit_delete_self;
        if ( IN_UNMOUNT == event )
                return &w->hit_unmount;
        if ( IN_MOVE_SELF == event )
                return &w->hit_move_self;
        if ( 0 == event )
                return &w->hit_total;
        return 0;
}

int inotifytools_get_stat_by_wd( int wd, int event ) {
        if (!collect_stats) return -1;

        watch *w = watch_from_wd(wd);
        if (!w) return -1;
        int *i = stat_ptr(w, event);
        if (!i) return -1;
        return *i;
}

int inotifytools_get_stat_total( int event ) {
        if (!collect_stats) return -1;
        if ( IN_ACCESS == event )
                return num_access;
        if ( IN_MODIFY == event )
                return num_modify;
        if ( IN_ATTRIB == event )
                return num_attrib;
        if ( IN_CLOSE_WRITE == event )
                return num_close_write;
        if ( IN_CLOSE_NOWRITE == event )
                return num_close_nowrite;
        if ( IN_OPEN == event )
                return num_open;
        if ( IN_MOVED_FROM == event )
                return num_moved_from;
        if ( IN_MOVED_TO == event )
                return num_moved_to;
        if ( IN_CREATE == event )
                return num_create;
        if ( IN_DELETE == event )
                return num_delete;
        if ( IN_DELETE_SELF == event )
                return num_delete_self;
        if ( IN_UNMOUNT == event )
                return num_unmount;
        if ( IN_MOVE_SELF == event )
                return num_move_self;

        if ( 0 == event )
                return num_total;

        return -1;
}

int inotifytools_get_stat_by_filename( char const * filename,
                                                int event ) {
        return inotifytools_get_stat_by_wd( inotifytools_wd_from_filename(
               filename ), event );
}

int inotifytools_error() {
        return error;
}

int isdir( char const * path ) {
        static struct stat64 my_stat;

        if ( -1 == lstat64( path, &my_stat ) ) {
                if (errno == ENOENT) return 0;
                fprintf(stderr, "Stat failed on %s: %s\n", path, strerror(errno));
                return 0;
        }

        return S_ISDIR( my_stat.st_mode ) && !S_ISLNK( my_stat.st_mode );
}


int inotifytools_get_num_watches() {
        int ret = 0;
        rbwalk(tree_filename, get_num, (void*)&ret);
        return ret;
}

int inotifytools_printf( struct inotify_event* event, char* fmt ) {
        return inotifytools_fprintf( stdout, event, fmt );
}

int inotifytools_fprintf( FILE* file, struct inotify_event* event, char* fmt ) {
        static char out[MAX_STRLEN+1];
        static int ret;
        ret = inotifytools_sprintf( out, event, fmt );
        if ( -1 != ret ) fprintf( file, "%s", out );
        return ret;
}

int inotifytools_sprintf( char * out, struct inotify_event* event, char* fmt ) {
        return inotifytools_snprintf( out, MAX_STRLEN, event, fmt );
}


int inotifytools_snprintf( char * out, int size,
                           struct inotify_event* event, char* fmt ) {
        static char * filename, * eventname, * eventstr;
        static unsigned int i, ind;
        static char ch1;
        static char timestr[MAX_STRLEN];
        static time_t now;


        if ( event->len > 0 ) {
                eventname = event->name;
        }
        else {
                eventname = NULL;
        }


        filename = inotifytools_filename_from_wd( event->wd );

        if ( !fmt || 0 == strlen(fmt) ) {
                error = EINVAL;
                return -1;
        }
        if ( strlen(fmt) > MAX_STRLEN || size > MAX_STRLEN) {
                error = EMSGSIZE;
                return -1;
        }

        ind = 0;
        for ( i = 0; i < strlen(fmt) &&
                     (int)ind < size - 1; ++i ) {
                if ( fmt[i] != '%' ) {
                        out[ind++] = fmt[i];
                        continue;
                }

                if ( i == strlen(fmt) - 1 ) {
                        // last character is %, invalid
                        error = EINVAL;
                        return ind;
                }

                ch1 = fmt[i+1];

                if ( ch1 == '%' ) {
                        out[ind++] = '%';
                        ++i;
                        continue;
                }

                if ( ch1 == 'w' ) {
                        if ( filename ) {
                                strncpy( &out[ind], filename, size - ind );
                                ind += strlen(filename);
                        }
                        ++i;
                        continue;
                }

                if ( ch1 == 'f' ) {
                        if ( eventname ) {
                                strncpy( &out[ind], eventname, size - ind );
                                ind += strlen(eventname);
                        }
                        ++i;
                        continue;
                }

                if ( ch1 == 'e' ) {
                        eventstr = inotifytools_event_to_str( event->mask );
                        strncpy( &out[ind], eventstr, size - ind );
                        ind += strlen(eventstr);
                        ++i;
                        continue;
                }

                if ( ch1 == 'T' ) {

                        if ( timefmt ) {

                                now = time(0);
                                if ( 0 >= strftime( timestr, MAX_STRLEN-1, timefmt,
                                                    localtime( &now ) ) ) {

                                        // time format probably invalid
                                        error = EINVAL;
                                        return ind;
                                }
                        }
                        else {
                                timestr[0] = 0;
                        }

                        strncpy( &out[ind], timestr, size - ind );
                        ind += strlen(timestr);
                        ++i;
                        continue;
                }

                // Check if next char in fmt is e
                if ( i < strlen(fmt) - 2 && fmt[i+2] == 'e' ) {
                        eventstr = inotifytools_event_to_str_sep( event->mask, ch1 );
                        strncpy( &out[ind], eventstr, size - ind );
                        ind += strlen(eventstr);
                        i += 2;
                        continue;
                }

                // OK, this wasn't a special format character, just output it as normal
                if ( ind < MAX_STRLEN ) out[ind++] = '%';
                if ( ind < MAX_STRLEN ) out[ind++] = ch1;
                ++i;
        }
        out[ind] = 0;

        return ind - 1;
}

void inotifytools_set_printf_timefmt( char * fmt ) {
        timefmt = fmt;
}

int inotifytools_get_max_queued_events() {
        int ret;
        if ( !read_num_from_file( QUEUE_SIZE_PATH, &ret ) ) return -1;
        return ret;
}

int inotifytools_get_max_user_instances() {
        int ret;
        if ( !read_num_from_file( INSTANCES_PATH, &ret ) ) return -1;
        return ret;
}

int inotifytools_get_max_user_watches() {
        int ret;
        if ( !read_num_from_file( WATCHES_SIZE_PATH, &ret ) ) return -1;
        return ret;
}

int inotifytools_ignore_events_by_regex( char const *pattern, int flags ) {
        if (!pattern) {
                if (regex) {
                        regfree(regex);
                        free(regex);
                        regex = 0;
                }
                return 1;
        }

        if (regex) { regfree(regex); }
        else       { regex = (regex_t *)malloc(sizeof(regex_t)); }

        int ret = regcomp(regex, pattern, flags | REG_NOSUB);
        if (0 == ret) return 1;

        regfree(regex);
        free(regex);
        regex = 0;
        error = EINVAL;
        return 0;
}

int event_compare(const void *p1, const void *p2, const void *config)
{
        if (!p1 || !p2) return p1 - p2;
        char asc = 1;
        int sort_event = (int)config;
        if (sort_event == -1) {
                sort_event = 0;
                asc = 0;
        } else if (sort_event < 0) {
                sort_event = -sort_event;
                asc = 0;
        }
        int *i1 = stat_ptr((watch*)p1, sort_event);
        int *i2 = stat_ptr((watch*)p2, sort_event);
        if (0 == *i1 - *i2) {
                return ((watch*)p1)->wd - ((watch*)p2)->wd;
        }
        if (asc)
                return *i1 - *i2;
        else
                return *i2 - *i1;
}

struct rbtree *inotifytools_wd_sorted_by_event(int sort_event)
{
        struct rbtree *ret = rbinit(event_compare, (void*)sort_event);
        RBLIST *all = rbopenlist(tree_wd);
        void const *p = rbreadlist(all);
        while (p) {
                void const *r = rbsearch(p, ret);
                niceassert((int)(r == p), "Couldn't insert watch into new tree");
                p = rbreadlist(all);
        }
        rbcloselist(all);
        return ret;
}