FAM_ALTBACKEND_DESC=		Alternate file monitor backend

FAM_ALTBACKEND_USES+=		autoreconf:build

FAM_ALTBACKEND_EXTRA_PATCHES=	${FILESDIR}/extra-patch-gio_kqueue_Makefile.am

post-patch-FAM_ALTBACKEND-on:

	@${CP} -f ${FILESDIR}/gkqueuefilemonitor.c.in ${WRKSRC}/gio/kqueue/gkqueuefilemonitor.c

	@${CP} ${FILESDIR}/kqueue_fnm.c.in ${WRKSRC}/gio/kqueue/kqueue_fnm.c

	@${CP} ${FILESDIR}/kqueue_fnm.h.in ${WRKSRC}/gio/kqueue/kqueue_fnm.h

	@(cd ${WRKSRC} && ${AUTORECONF} -fvi)

--- gio/kqueue/Makefile.am.orig	2015-10-14 14:41:16.000000000 +0300

+++ gio/kqueue/Makefile.am	2016-11-06 05:08:37.646089000 +0300

@@ -4,21 +4,8 @@

 libkqueue_la_SOURCES = \

        gkqueuefilemonitor.c \

-       gkqueuefilemonitor.h \

-       kqueue-helper.c \

-       kqueue-helper.h \

-       kqueue-thread.c \

-       kqueue-thread.h \

-       kqueue-sub.c \

-       kqueue-sub.h \

-       kqueue-missing.c \

-       kqueue-missing.h \

-       kqueue-utils.c \

-       kqueue-utils.h \

-       kqueue-exclusions.c \

-       kqueue-exclusions.h \

-       dep-list.c \

-       dep-list.h \

+       kqueue_fnm.c \

+       kqueue_fnm.h \

        $(NULL)

 libkqueue_la_CFLAGS = \

/*-

 * Copyright (c) 2016 - 2017 Rozhuk Ivan <rozhuk.im@gmail.com>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 * Author: Rozhuk Ivan <rozhuk.im@gmail.com>

 *

 */

#include "config.h"

#include <glib-object.h>

#include <string.h>

#include <gio/gfilemonitor.h>

#include <gio/glocalfilemonitor.h>

#include <gio/giomodule.h>

#include "glib-private.h"

#include <glib-unix.h>

#include "kqueue_fnm.h"

static GMutex			kqueue_lock;

static volatile kqueue_fnm_p	kqueue_fnm = NULL;

#define G_TYPE_KQUEUE_FILE_MONITOR      (g_kqueue_file_monitor_get_type())

#define G_KQUEUE_FILE_MONITOR(inst)     (G_TYPE_CHECK_INSTANCE_CAST((inst), \

					 G_TYPE_KQUEUE_FILE_MONITOR, GKqueueFileMonitor))

typedef GLocalFileMonitorClass	GKqueueFileMonitorClass;

typedef struct {

	GLocalFileMonitor	parent_instance;

	kqueue_file_mon_data_p	fmd;

} GKqueueFileMonitor;

GType g_kqueue_file_monitor_get_type(void);

G_DEFINE_TYPE_WITH_CODE (GKqueueFileMonitor, g_kqueue_file_monitor, G_TYPE_LOCAL_FILE_MONITOR,

       g_io_extension_point_implement(G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME,

               g_define_type_id,

               "kqueue",

               10))

static void

kqueue_event_handler(kqueue_fnm_p kfnm,

    kqueue_file_mon_data_p fmd, void *udata, uint32_t event,

    const char *base, const char *filename, const char *new_filename) {

	static const uint32_t kfnm_to_glib_map[] = {

		0,				/* KF_EVENT_NOT_CHANGED */

		G_FILE_MONITOR_EVENT_CREATED,	/* KF_EVENT_CREATED */

		G_FILE_MONITOR_EVENT_DELETED,	/* KF_EVENT_DELETED */

		G_FILE_MONITOR_EVENT_RENAMED,	/* KF_EVENT_RENAMED */

		G_FILE_MONITOR_EVENT_CHANGED	/* KF_EVENT_CHANGED */

	};

	if (NULL == kfnm || NULL == filename ||

	    KF_EVENT_CREATED > event ||

	    KF_EVENT_CHANGED < event)

		return;

	g_file_monitor_source_handle_event(udata,

	    kfnm_to_glib_map[event],

	    filename, new_filename, NULL,

	    g_get_monotonic_time());

}

static gboolean

g_kqueue_file_monitor_is_supported(void) {

	if (NULL != kqueue_fnm)

		return (TRUE);

	/* Init only once. */

	g_mutex_lock(&kqueue_lock);

	if (NULL != kqueue_fnm) {

		g_mutex_unlock(&kqueue_lock);

		return (TRUE); /* Initialized while wait lock. */

	}

	kqueue_fnm = kqueue_fnm_create(1, kqueue_event_handler);

	if (NULL == kqueue_fnm) {

		g_mutex_unlock(&kqueue_lock);

		return (FALSE); /* Init fail. */

	}

	g_mutex_unlock(&kqueue_lock);

	return (TRUE);

}

static gboolean

g_kqueue_file_monitor_cancel(GFileMonitor *monitor) {

	GKqueueFileMonitor *gffm = G_KQUEUE_FILE_MONITOR(monitor);

	kqueue_fnm_del(kqueue_fnm, gffm->fmd);

	gffm->fmd = NULL;

	return (TRUE);

}

static void

g_kqueue_file_monitor_finalize(GObject *object) {

	GKqueueFileMonitor *gffm = G_KQUEUE_FILE_MONITOR(object);

	kqueue_fnm_del(kqueue_fnm, gffm->fmd);

	gffm->fmd = NULL;

}

static void

g_kqueue_file_monitor_start(GLocalFileMonitor *local_monitor,

    const gchar *dirname, const gchar *basename,

    const gchar *filename, GFileMonitorSource *source) {

	GKqueueFileMonitor *gffm = G_KQUEUE_FILE_MONITOR (local_monitor);

	g_assert(NULL != kqueue_fnm);

	g_source_ref((GSource*)source);

	if (NULL == filename) {

		filename = dirname;

	}

	gffm->fmd = kqueue_fnm_add(kqueue_fnm, filename, source);

}

static void

g_kqueue_file_monitor_init(GKqueueFileMonitor *monitor) {

}

static void

g_kqueue_file_monitor_class_init(GKqueueFileMonitorClass *class) {

	GObjectClass *gobject_class = G_OBJECT_CLASS(class);

	GFileMonitorClass *file_monitor_class = G_FILE_MONITOR_CLASS(class);

	class->is_supported = g_kqueue_file_monitor_is_supported;

	class->start = g_kqueue_file_monitor_start;

	class->mount_notify = TRUE; /* TODO: ??? */

	file_monitor_class->cancel = g_kqueue_file_monitor_cancel;

	gobject_class->finalize = g_kqueue_file_monitor_finalize;

}

static void

g_kqueue_file_monitor_class_finalize(GKqueueFileMonitorClass *class) {

}

void

g_io_module_load(GIOModule *module) {

	g_type_module_use(G_TYPE_MODULE(module));

	g_io_extension_point_implement(G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME,

	    G_TYPE_KQUEUE_FILE_MONITOR, "kqueue", 10);

	g_io_extension_point_implement(G_NFS_FILE_MONITOR_EXTENSION_POINT_NAME,

	    G_TYPE_KQUEUE_FILE_MONITOR, "kqueue", 10);

}

void

g_io_module_unload(GIOModule *module) {

	g_assert_not_reached();

}

char **

g_io_module_query(void) {

	char *eps[] = {

		G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME,

		G_NFS_FILE_MONITOR_EXTENSION_POINT_NAME,

		NULL

	};

	return (g_strdupv(eps));

}

/*-

 * Copyright (c) 2016 - 2017 Rozhuk Ivan <rozhuk.im@gmail.com>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 * Author: Rozhuk Ivan <rozhuk.im@gmail.com>

 *

 */

#include <sys/param.h>

#include <sys/types.h>

#include <sys/event.h>

#include <sys/stat.h>

#include <sys/fcntl.h> /* open, fcntl */

#include <inttypes.h>

#include <stdlib.h> /* malloc, exit */

#include <unistd.h> /* close, write, sysconf */

#include <string.h> /* bcopy, bzero, memcpy, memmove, memset, strerror... */

#include <dirent.h> /* opendir, readdir */

#include <errno.h>

#include <pthread.h>

#include "kqueue_fnm.h"

/* Preallocate items count. */

#ifndef FILES_ALLOC_BLK_SIZE

#	define FILES_ALLOC_BLK_SIZE	32

#endif

typedef struct file_info_s { /* Directory file. */

	struct dirent 	de;		/* d_reclen used for action. */

	struct stat	sb;

} file_info_t, *file_info_p;

typedef struct readdir_data_s {

	int		fd;

	uint8_t		*buf;

	size_t		buf_size;

	size_t		buf_used;

	size_t		buf_pos;

} readdir_data_t, *readdir_data_p;

typedef struct kqueue_file_mon_data_s {

	int		fd;		/* fd for notify kqueue(). */

	int		is_dir;

	char		path[(PATH_MAX + 2)];

	size_t		path_size;

	size_t		name_offset;	/* Parent path size. */

	size_t		st_blksize;

	void		*udata;

	kqueue_fnm_p	kfnm;

	/* For dir. */

	file_info_p	files;

	volatile size_t	files_count;

	size_t		files_allocated;

} kqueue_file_mon_data_t;

typedef struct kqueue_file_nonify_monitor_s {

	int		fd;		/* kqueue() fd. */

	int		pfd[2];		/* pipe queue specific. */

	uint8_t		*tmpbuf;

	size_t		tmpbuf_size;

	kfnm_event_handler_cb cb_func;	/* Callback on dir/file change. */

	pthread_t	tid;

} kqueue_fnm_t;

typedef void (*kq_msg_cb)(kqueue_file_mon_data_p fmd);

typedef struct kqueue_file_mon_msg_pkt_s {

	size_t		magic;

	kq_msg_cb	msg_cb;

	kqueue_file_mon_data_p fmd;

	size_t		chk_sum;

} kqueue_fnm_msg_pkt_t, *kqueue_fnm_msg_pkt_p;

#define KF_MSG_PKT_MAGIC	0xffddaa00

#ifndef O_NOATIME

#	define O_NOATIME	0

#endif

#ifndef O_EVTONLY

#	define O_EVTONLY	O_RDONLY

#endif

#define OPEN_FILE_FLAGS		(O_EVTONLY | O_NONBLOCK | O_NOFOLLOW | O_NOATIME | O_CLOEXEC)

#define EVFILT_VNODE_FLAGS_ALL	(NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE)

#ifndef _GENERIC_DIRSIZ

#	define _GENERIC_DIRSIZ(__de)	MIN((__de)->d_reclen, sizeof(struct dirent))

#endif

#define IS_NAME_DOTS(__name)	('.' == (__name)[0] &&			\

				 ('\0' == (__name)[1] || 		\

				  ('.' == (__name)[1] && '\0' == (__name)[2])))

#define IS_DE_NAME_EQ(__de1, __de2)  (0 == mem_cmpn((__de1)->d_name,	\

						    (__de1)->d_namlen,	\

						    (__de2)->d_name,	\

						    (__de2)->d_namlen))

#define zalloc(__size)		calloc(1, (__size))

void 	*kqueue_fnm_proccess_events_proc(void *data);

static inline int

mem_cmpn(const void *buf1, const size_t buf1_size,

    const void *buf2, const size_t buf2_size) {

	if (buf1_size != buf2_size)

		return (((buf1_size > buf2_size) ? 127 : -127));

	if (0 == buf1_size || buf1 == buf2)

		return (0);

	if (NULL == buf1)

		return (-127);

	if (NULL == buf2)

		return (127);

	return (memcmp(buf1, buf2, buf1_size));

}

static inline int

realloc_items(void **items, const size_t item_size,

    size_t *allocated, const size_t alloc_blk_cnt, const size_t count) {

	size_t allocated_prev, allocated_new;

	uint8_t *items_new;

	if (NULL == items || 0 == item_size || NULL == allocated ||

	    0 == alloc_blk_cnt)

		return (EINVAL);

	allocated_prev = (*allocated);

	if (NULL != (*items) &&

	    allocated_prev > count &&

	    allocated_prev <= (count + alloc_blk_cnt))

		return (0);

	allocated_new = (((count / alloc_blk_cnt) + 1) * alloc_blk_cnt);

#if (defined(__FreeBSD_version) && __FreeBSD_version >= 1100000) || defined(HAVE_REALLOCARRAY)

	items_new = (uint8_t*)reallocarray((*items), item_size, allocated_new);

#else /* For old BSD systems. */

	items_new = (uint8_t*)realloc((*items), (item_size * allocated_new));

#endif

	if (NULL == items_new) /* Realloc fail! */

		return (ENOMEM);

	if (allocated_new > allocated_prev) { /* Init new mem. */

		bzero((items_new + (allocated_prev * item_size)),

		    ((allocated_new - allocated_prev) * item_size));

	}

	(*items) = items_new;

	(*allocated) = allocated_new;

	return (0);

}

static int

readdir_data_start(int fd, uint8_t *buf, size_t buf_size, readdir_data_p rdd) {

	if (-1 == fd || NULL == buf || 0 == buf_size || NULL == rdd)

		return (EINVAL);

	if (-1 == lseek(fd, 0, SEEK_SET))

		return (errno);

	bzero(rdd, sizeof(readdir_data_t));

	rdd->fd = fd;

	rdd->buf = buf;

	rdd->buf_size = buf_size;

	return (0);

}

static int

readdir_data_next(readdir_data_p rdd, struct dirent *de) {

	int ios;

	uint8_t *ptr;

	if (NULL == rdd || NULL == de)

		return (EINVAL);

retry:

	if (rdd->buf_used <= rdd->buf_pos) {

		ios = getdents(rdd->fd, (char*)rdd->buf, rdd->buf_size);

		if (-1 == ios)

			return (errno);

		rdd->buf_used = (size_t)ios;

		rdd->buf_pos = 0;

		if (0 == ios)

			return (ESPIPE); /* EOF. */

	}

	/* Keep data aligned. */

	ptr = (rdd->buf + rdd->buf_pos);

	memcpy(de, ptr, (sizeof(struct dirent) - sizeof(de->d_name)));

	if (0 == de->d_reclen)

		return (ESPIPE); /* EOF. */

	rdd->buf_pos += de->d_reclen;

#ifdef DT_WHT

	if (DT_WHT == de->d_type)

		goto retry;

#endif

	memcpy(de, ptr, _GENERIC_DIRSIZ(de));

	if (IS_NAME_DOTS(de->d_name))

		goto retry;

	return (0);

}

static int

file_info_find_de_fileno(file_info_p files, size_t files_count,

    struct dirent *de, size_t *idx) {

	size_t i;

	if (NULL == files || NULL == de || NULL == idx)

		return (0);

	for (i = 0; i < files_count; i ++) {

		if (de->d_type != files[i].de.d_type ||

		    de->d_fileno != files[i].de.d_fileno)

			continue;

		(*idx) = i;

		return (1);

	}

	(*idx) = files_count;

	return (0);

}

static int

file_info_find_de_name(file_info_p files, size_t files_count,

    const size_t skip_idx, struct dirent *de, size_t *idx) {

	size_t i;

	if (NULL == files || NULL == de || NULL == idx)

		return (0);

	for (i = 0; i < files_count; i ++) {

		if (i == skip_idx ||

		    de->d_type != files[i].de.d_type ||

		    0 == IS_DE_NAME_EQ(de, &files[i].de))

			continue;

		(*idx) = i;

		return (1);

	}

	(*idx) = files_count;

	return (0);

}

static void

kqueue_file_mon_data_clean(kqueue_file_mon_data_p fmd) {

	if (NULL == fmd)

		return;

	close(fmd->fd);

	fmd->fd = -1;

	fmd->files_count = 0;

	fmd->files_allocated = 0;

	free(fmd->files);

	fmd->files = NULL;

}

static void

kqueue_file_mon_data_free(kqueue_file_mon_data_p fmd) {

	if (NULL == fmd)

		return;

	close(fmd->fd);

	free(fmd->files);

	free(fmd);

}

static kqueue_file_mon_data_p

kqueue_file_mon_data_alloc(kqueue_fnm_p kfnm, const char *path, void *udata) {

	kqueue_file_mon_data_p fmd;

	if (NULL == kfnm || NULL == path)

		return (NULL);

	fmd = zalloc(sizeof(kqueue_file_mon_data_t));

	if (NULL == fmd)

		return (NULL);

	/* Remember args. */

	fmd->path_size = strlcpy(fmd->path, path, PATH_MAX);

	fmd->name_offset = fmd->path_size;

	fmd->udata = udata;

	fmd->kfnm = kfnm;

	return (fmd);

}

static int

kqueue_file_mon_data_readdir(kqueue_file_mon_data_p fmd) {

	int error;

	struct dirent *de;

	uint8_t *tmpbuf;

	readdir_data_t rdd;

	if (NULL == fmd || 0 == fmd->is_dir)

		return (EINVAL);

	/* Get temp buf. */

	if (fmd->st_blksize > fmd->kfnm->tmpbuf_size) {

		tmpbuf = realloc(fmd->kfnm->tmpbuf, fmd->st_blksize);

		if (NULL == tmpbuf)

			return (ENOMEM);

		fmd->kfnm->tmpbuf = tmpbuf;

		fmd->kfnm->tmpbuf_size = fmd->st_blksize;

	}

	fmd->files_count = 0;

	fmd->files_allocated = 0;

	free(fmd->files);

	fmd->files = NULL;

	error = readdir_data_start(fmd->fd, fmd->kfnm->tmpbuf, fmd->st_blksize, &rdd);

	if (0 != error)

		return (error);

	for (;;) {

		if (0 != realloc_items((void**)&fmd->files,

		    sizeof(file_info_t), &fmd->files_allocated,

		    FILES_ALLOC_BLK_SIZE, fmd->files_count)) {

			fmd->files_count = 0;

			fmd->files_allocated = 0;

			free(fmd->files);

			fmd->files = NULL;

			return (ENOMEM);

		}

		de = &fmd->files[fmd->files_count].de; /* Use short name. */

		/* Get file name from folder. */

		if (0 != readdir_data_next(&rdd, de))

			break;

		/* Get file attrs. */

		if (0 != fstatat(fmd->fd, de->d_name,

		    &fmd->files[fmd->files_count].sb,

		    AT_SYMLINK_NOFOLLOW)) {

			bzero(&fmd->files[fmd->files_count].sb,

			    sizeof(struct stat));

		}

		fmd->files_count ++;

	}

	return (0); /* OK. */

}

static void

kqueue_file_mon_data_init(kqueue_file_mon_data_p fmd) {

	struct stat sb;

	struct kevent kev;

	struct timespec ke_timeout;

	if (NULL == fmd)

		return;

	fmd->fd = open(fmd->path, OPEN_FILE_FLAGS);

	if (-1 == fmd->fd)

		return;

	if (0 != fstat(fmd->fd, &sb))

		goto err_out;

	fmd->st_blksize = (size_t)sb.st_blksize;

	/* Get parent folder name. */

	if (S_ISDIR(sb.st_mode)) {

		fmd->is_dir = 1;

		/* Be sure that folder contain trailing '/'. */

		if ('/' != fmd->path[(fmd->path_size - 1)]) {

			fmd->path[fmd->path_size] = '/';

			fmd->path_size ++;

			fmd->path[fmd->path_size] = 0;

		}

		/* Skip last '/' for parent dir search. */

		fmd->name_offset = (fmd->path_size - 1);

	}

	/* Find parent dir path size. */

	while (0 < fmd->name_offset && '/' != fmd->path[(fmd->name_offset - 1)]) {

		fmd->name_offset --;

	}

	/* Dir special processing. */

	if (0 != fmd->is_dir) {

		/* Read and remember dir content. */

		if (0 != kqueue_file_mon_data_readdir(fmd))

			goto err_out;

	}

	/* Add to kqueue. */

	bzero(&kev, sizeof(kev));

	kev.ident = (uintptr_t)fmd->fd;

	kev.filter = EVFILT_VNODE;

	kev.flags = (EV_ADD | EV_CLEAR);

	kev.fflags = EVFILT_VNODE_FLAGS_ALL;

	kev.udata = (void*)fmd;

	bzero(&ke_timeout, sizeof(ke_timeout));

	if (-1 == kevent(fmd->kfnm->fd, &kev, 1, NULL, 0, &ke_timeout))

		goto err_out;

	return; /* OK. */

err_out:

	kqueue_file_mon_data_clean(fmd);

}

static void

kqueue_handle_changes(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd) {

	struct stat sb;

	size_t i, k, files_count;

	file_info_p files;

	if (NULL == kfnm || NULL == fmd)

		return;

	if (0 != fstat(fmd->fd, &sb) ||

	    0 == sb.st_nlink) {

		kqueue_file_mon_data_clean(fmd);

		kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED,

		    fmd->path, "", NULL);

		return;

	}

	if (0 == fmd->is_dir) {

		fmd->path[fmd->name_offset] = 0;

		kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_CHANGED, fmd->path,

		    (fmd->path + fmd->name_offset), NULL);

		fmd->path[fmd->name_offset] = '/';

		return;

	}

	/* Dir processing. */

	/* Save prev. */

	files = fmd->files;

	files_count = fmd->files_count;

	fmd->files = NULL;

	fmd->files_count = 0;

	/* Update dir. */

	if (0 != kqueue_file_mon_data_readdir(fmd))

		goto err_out;

	/* Notify removed first. */

	for (i = 0; i < files_count; i ++) {

		if (0 != file_info_find_de_fileno(fmd->files, fmd->files_count, &files[i].de, &k) ||

		    0 != file_info_find_de_name(fmd->files, fmd->files_count, ~0, &files[i].de, &k)) /* Deleted. */

			continue;

		kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED,

			    fmd->path, files[i].de.d_name, NULL);

	}

	/* Notify. */

	for (i = 0; i < fmd->files_count; i ++) {

		/* Is new file/folder? */

		if (0 == file_info_find_de_fileno(files, files_count, &fmd->files[i].de, &k) &&

		    0 == file_info_find_de_name(files, files_count, ~0, &fmd->files[i].de, &k)) { /* Add new. */

			kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_CREATED,

			    fmd->path, fmd->files[i].de.d_name, NULL);

			continue;

		}

		/* Is renamed? */

		if (0 == IS_DE_NAME_EQ(&files[k].de, &fmd->files[i].de)) {

			kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_RENAMED,

			    fmd->path, files[k].de.d_name, fmd->files[i].de.d_name);

			continue;

		}

		/* Is modified? */

		if (0 != memcmp(&fmd->files[i].sb, &files[k].sb, sizeof(struct stat))) {

			kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_CHANGED,

			    fmd->path, fmd->files[i].de.d_name, NULL);

			continue;

		}

		/* Not changed. */

	}

err_out:

	free(files);

}

static void

kqueue_handle_rename(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd) {

	int up_dir_fd, found = 0;

	readdir_data_t rdd;

	struct dirent de;

	struct stat sb;

	char old_filename[(MAXNAMLEN + 2)];

	size_t old_filename_size;

	if (NULL == kfnm || NULL == fmd)

		return;

	if (0 != fstat(fmd->fd, &sb) ||

	    0 == sb.st_nlink) {

notify_removed:

		kqueue_file_mon_data_clean(fmd);

		kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED,

		    fmd->path, "", NULL);

		return;

	}

	/* Save old file name. */

	old_filename_size = (fmd->path_size - fmd->name_offset - fmd->is_dir);

	memcpy(old_filename,

	    (fmd->path + fmd->name_offset),

	    old_filename_size);

	old_filename[old_filename_size] = 0;

	/* Get parent folder name. */

	fmd->path[fmd->name_offset] = 0;

	/* Try to open. */

	up_dir_fd = open(fmd->path, (OPEN_FILE_FLAGS | O_DIRECTORY));

	/* Restore '/' after parent folder. */

	fmd->path[fmd->name_offset] = '/';

	if (-1 == up_dir_fd ||

	    0 != fstat(up_dir_fd, &sb) ||

	    0 != readdir_data_start(up_dir_fd, fmd->kfnm->tmpbuf, sb.st_blksize, &rdd)) {

		close(up_dir_fd);

		return;

	}

	/* Find new name by inode. */

	while (0 == readdir_data_next(&rdd, &de)) {

		if (de.d_fileno == sb.st_ino) {

			found ++;

			break;

		}

	}

	close(up_dir_fd);

	if (0 == found)

		goto notify_removed; /* Not found. */

	/* Update name. */

	if (PATH_MAX <= (fmd->name_offset + de.d_namlen))

		return; /* Too long. */

	memcpy((fmd->path + fmd->name_offset), de.d_name, de.d_namlen);

	fmd->path_size = (fmd->name_offset + de.d_namlen);

	/* Add last '/' for dir. */

	fmd->path[fmd->path_size] = '/';

	fmd->path_size += fmd->is_dir;

	fmd->path[fmd->path_size] = 0;

	/* Notify. */

	kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_RENAMED,

	    fmd->path, old_filename, de.d_name);

}

static void

kqueue_fnm_delay_call_process(kqueue_fnm_p kfnm, kq_msg_cb forced_msg_cb) {

	ssize_t ios;

	kqueue_fnm_msg_pkt_t msg;

	for (;;) {

		ios = read(kfnm->pfd[0], &msg, sizeof(msg));

		if (0 >= ios)

			return;

		if (sizeof(msg) != ios ||

		    KF_MSG_PKT_MAGIC != msg.magic ||

		    (((size_t)msg.msg_cb) ^ ((size_t)msg.fmd)) != msg.chk_sum)

			continue;

		if (NULL != forced_msg_cb) {

			forced_msg_cb(msg.fmd);

			continue;

		}

		if (NULL == msg.msg_cb)

			continue;

		msg.msg_cb(msg.fmd);

	}

}

static int

kqueue_fnm_delay_call(kqueue_fnm_p kfnm, kq_msg_cb msg_cb,

    kqueue_file_mon_data_p fmd) {

	kqueue_fnm_msg_pkt_t msg;

	if (NULL == kfnm || NULL == fmd)

		return (EINVAL);

	msg.magic = KF_MSG_PKT_MAGIC;

	msg.msg_cb = msg_cb;

	msg.fmd = fmd;

	msg.chk_sum = (((size_t)msg.msg_cb) ^ ((size_t)msg.fmd));

	if (sizeof(msg) == write(kfnm->pfd[1], &msg, sizeof(msg)))

		return (0);

	return (errno);

}

void

kqueue_fnm_free(kqueue_fnm_p kfnm) {

	if (NULL == kfnm)

		return;

	close(kfnm->fd);

	pthread_join(kfnm->tid, NULL);

	/* Free all in delay calls queue. */

	kqueue_fnm_delay_call_process(kfnm, kqueue_file_mon_data_free);

	close(kfnm->pfd[0]);

	close(kfnm->pfd[1]);

	free(kfnm->tmpbuf);

	free(kfnm);

}

kqueue_fnm_p

kqueue_fnm_create(int use_thread, kfnm_event_handler_cb cb_func) {

	kqueue_fnm_p kfnm;

	struct kevent kev;

	struct timespec ke_timeout;

	if (NULL == cb_func)

		return (NULL);

	kfnm = zalloc(sizeof(kqueue_fnm_t));

	if (NULL == kfnm)

		return (NULL);

	kfnm->fd = kqueue();

	if (-1 == kfnm->fd)

		goto err_out;

	if (-1 == pipe2(kfnm->pfd, O_NONBLOCK))

		goto err_out;

	kfnm->cb_func = cb_func;

	bzero(&kev, sizeof(kev));

	kev.ident = kfnm->pfd[0];

	kev.filter = EVFILT_READ;

	kev.flags = (EV_ADD | EV_ENABLE);

	bzero(&ke_timeout, sizeof(ke_timeout));

	if (-1 == kevent(kfnm->fd, &kev, 1, NULL, 0, &ke_timeout))

		goto err_out;

	if (0 != use_thread) {

		if (0 != pthread_create(&kfnm->tid, NULL,

		    kqueue_fnm_proccess_events_proc, kfnm))

			goto err_out;

	}

	return (kfnm);

err_out:

	kqueue_fnm_free(kfnm);

	return (NULL);

}

kqueue_file_mon_data_p

kqueue_fnm_add(kqueue_fnm_p kfnm, const char *path, void *udata) {

	int error;

	kqueue_file_mon_data_p fmd;

	if (NULL == kfnm || NULL == path)

		return (NULL);

	fmd = kqueue_file_mon_data_alloc(kfnm, path, udata);

	if (NULL == fmd)

		return (NULL);

	/* Shedule delay call to init. */

	error = kqueue_fnm_delay_call(kfnm, kqueue_file_mon_data_init, fmd);

	if (0 != error) { /* Error, do no directly init to avoid freezes. */

		kqueue_file_mon_data_free(fmd);

		return (NULL);

	}

	return (fmd);

}

void

kqueue_fnm_del(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd) {

	int error;

	if (NULL == kfnm || NULL == fmd)

		return;

	/* Cancel notifications. */

	close(fmd->fd);

	fmd->fd = -1;

	/* Shedule delay call to free. */

	error = kqueue_fnm_delay_call(kfnm, kqueue_file_mon_data_free, fmd);

	if (0 == error)

		return;

	/* Error, free directly. */

	kqueue_file_mon_data_free(fmd);

}

static void

kqueue_fnm_proccess_event(kqueue_fnm_p kfnm, struct kevent *kev) {

	kqueue_file_mon_data_p fmd;

	if (NULL == kfnm || NULL == kev)

		return;

	if (kev->ident == (uintptr_t)kfnm->pfd[0] &&

	    kev->filter == EVFILT_READ) { /* Handle delay calls. */

		kqueue_fnm_delay_call_process(kfnm, NULL);

		return;

	}

	if (EVFILT_VNODE != kev->filter ||

	    0 == kev->udata)

		return; /* Unknown event or no associated data, skip. */

	fmd = (kqueue_file_mon_data_p)kev->udata;

	if (EV_ERROR & kev->flags) {

		kev->flags |= NOTE_REVOKE; /* Treat error as unmount. */

	}

	if (NOTE_RENAME & kev->fflags) {

		kqueue_handle_rename(kfnm, fmd);

	}

	if ((NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB) & kev->fflags) {

		kqueue_handle_changes(kfnm, fmd);

	}

	if ((NOTE_DELETE | NOTE_REVOKE) & kev->fflags) {

		kqueue_file_mon_data_clean(fmd);

		kfnm->cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED,

		    fmd->path, "", NULL);

	}

}

void *

kqueue_fnm_proccess_events_proc(void *data) {

	struct kevent kev;

	kqueue_fnm_p kfnm = data;

	if (NULL == kfnm)

		return (NULL);

	/* Get and proccess events, no wait. */

	while (0 < kevent(kfnm->fd, NULL, 0, &kev, 1, NULL)) {

		kqueue_fnm_proccess_event(kfnm, &kev);

	}

	return (NULL);

}

int

kqueue_fnm_get_ev_recv_fd(kqueue_fnm_p kfnm) {

	if (NULL == kfnm || NULL != kfnm->tid)

		return (-1);

	return (kfnm->fd);

}

void

kqueue_fnm_proccess_events(kqueue_fnm_p kfnm) {

	struct kevent kev;

	struct timespec ke_timeout;

	if (NULL == kfnm || NULL != kfnm->tid)

		return;

	/* Get and proccess events, no wait. */

	bzero(&ke_timeout, sizeof(ke_timeout));

	while (0 < kevent(kfnm->fd, NULL, 0, &kev, 1, &ke_timeout)) {

		kqueue_fnm_proccess_event(kfnm, &kev);

	}

}

/*-

 * Copyright (c) 2016 - 2017 Rozhuk Ivan <rozhuk.im@gmail.com>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 * Author: Rozhuk Ivan <rozhuk.im@gmail.com>

 *

 */

#ifndef __KQUEUE_FILE_NOTIFY_MONITOR_H__

#define __KQUEUE_FILE_NOTIFY_MONITOR_H__

#include <sys/param.h>

#include <sys/types.h>

#include <inttypes.h>

typedef struct kqueue_file_nonify_monitor_s	*kqueue_fnm_p;

typedef struct kqueue_file_mon_data_s		*kqueue_file_mon_data_p;

typedef void (*kfnm_event_handler_cb)(kqueue_fnm_p kfnm,

			       kqueue_file_mon_data_p fmd, void *udata,

			       uint32_t event,

			       const char *base,

			       const char *filename,

			       const char *new_filename);

#define KF_EVENT_NOT_CHANGED	0 /* Internal use. */

#define KF_EVENT_CREATED	1

#define KF_EVENT_DELETED	2

#define KF_EVENT_RENAMED	3

#define KF_EVENT_CHANGED	4

kqueue_fnm_p	kqueue_fnm_create(int use_thread, kfnm_event_handler_cb cb_func);

void		kqueue_fnm_free(kqueue_fnm_p kfnm);

kqueue_file_mon_data_p	kqueue_fnm_add(kqueue_fnm_p kfnm,

			    const char *path, void *udata);

void		kqueue_fnm_del(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd);

int		kqueue_fnm_get_ev_recv_fd(kqueue_fnm_p kfnm);

void		kqueue_fnm_proccess_events(kqueue_fnm_p kfnm);

#endif /* __KQUEUE_FILE_NOTIFY_MONITOR_H__ */