pnotify-internal.h

/*              $Id: $          */

/*
 * Copyright (c) 2007 Mark Heily <devel@heily.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _PNOTIFY_INTERNAL_H
#define _PNOTIFY_INTERNAL_H

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <dirent.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "pnotify.h"
#include "queue.h"
#include "thread.h"

/* WORKAROUND */
#if defined(__linux__)
# define HAVE_INOTIFY 1
# include <sys/inotify.h>
# include <sys/epoll.h>
#else
# define HAVE_KQUEUE 1
# include <sys/event.h>
#endif

struct pnotify_event {

        struct pn_watch *watch;

        int       parent;

        int       mask;

        char      name[NAME_MAX + 1];

        TAILQ_ENTRY(pnotify_event) entries;
};

struct pnotify_ctx {

        TAILQ_HEAD(, pnotify_event) event;

        pthread_mutex_t mutex;

        sem_t event_count;
};

struct directory {

        char    *path;
        size_t   path_len;

        DIR     *dirp;

        /* All entries in the directory (struct dirent) */
        LIST_HEAD(, dentry) all;
};

struct dentry {

        struct dirent   ent;

        int  fd;

        struct stat     st;

        int mask;

        LIST_ENTRY(dentry) entries;
};

struct pn_watch {

        /* ---- public fields accessible via pnotify_watch structure */

        enum pn_watch_type type;

        enum pn_event_bitmask mask;

        union pn_resource_id ident;

        void (*cb)();
        void *arg;

        /* ---- private fields accessible via pn_watch structure */

        struct pnotify_ctx * ctx;

        int             fd;     
        int             wd;     
        bool            is_dir; 
        /* A list of directory entries (only used if is_dir is true) */
        struct directory dir;

        /* The parent watch descriptor, for watches that are
           automatically added on files within a monitored
           directory. If zero, there is no parent.
         */
        int parent_wd;

#if HAVE_KQUEUE

        /* The associated kernel event structure */
        struct kevent    kev;

        /* The pathname of the directory (only for directories) */
        char path[PATH_MAX + 1];

#elif __linux__

        struct epoll_event epoll_evt;

#endif

        /* Pointer to the next watch */
        LIST_ENTRY(pn_watch) entries;
};


/* The 'dprintf' macro is used for printf() debugging */
#if PNOTIFY_DEBUG
# define dprintf printf
# define dprint_event(e) (void) pnotify_print_event(e)
#else
# define dprintf(...)    do { ; } while (0)
# define dprint_event(e) do { ; } while (0)
#endif

#define WATCH_MAX 1000

/* Forward declarations for private functions */

int pnotify_reap_signal(struct pnotify_event *, struct pnotify_ctx *);
int sys_trap_signal(struct pnotify_ctx *, int signum);
int pn_trap_signal(struct pnotify_ctx *, int signum);
void * pn_signal_loop(void *);
void * pn_timer_loop(void *);
void pn_event_add(struct pnotify_ctx *, struct pnotify_event *);
struct pn_watch * pn_get_watch_by_id(int wd);
void pn_mask_signals();
void pn_timer_init(void);
int pn_add_timer(struct pn_watch *watch);
int pn_rm_timer(struct pn_watch *watch);

/* vtable for system-specific functions */
struct pnotify_vtable {
        void (*init_once)(void);
        int (*add_watch)(struct pn_watch *);
        int (*rm_watch)(struct pn_watch *);
        void (*cleanup)();
};
extern const struct pnotify_vtable * const sys;
extern const struct pnotify_vtable LINUX_VTABLE;
extern const struct pnotify_vtable BSD_VTABLE;

#endif /* _PNOTIFY_INTERNAL_H */

---