Update to the latest upstream snapshot

13 files changed, 507 insertions, 254 deletions

diff --git a/src/libmowgli/eventloop/epoll_pollops.c b/src/libmowgli/eventloop/epoll_pollops.c
index 596b992..a77c882 100644
--- a/src/libmowgli/eventloop/epoll_pollops.c
+++ b/src/libmowgli/eventloop/epoll_pollops.c
@@ -22,15 +22,17 @@
 
 #ifdef HAVE_SYS_EPOLL_H
 
-#include <sys/epoll.h>
+# include <sys/epoll.h>
 
-typedef struct {
+typedef struct
+{
 	int epoll_fd;
 	int pfd_size;
 	struct epoll_event *pfd;
 } mowgli_epoll_eventloop_private_t;
 
-static void mowgli_epoll_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_epoll_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	mowgli_epoll_eventloop_private_t *priv;
 
@@ -38,13 +40,14 @@ static void mowgli_epoll_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	eventloop->poller = priv;
 
 	priv->pfd_size = getdtablesize();
-	priv->epoll_fd = epoll_create(priv->pfd_size);
+	priv->epoll_fd = epoll_create1(EPOLL_CLOEXEC); /* Linux 2.6.27+ */
 	priv->pfd = mowgli_alloc(sizeof(struct epoll_event) * priv->pfd_size);
 
 	return;
 }
 
-static void mowgli_epoll_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_epoll_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	mowgli_epoll_eventloop_private_t *priv;
 
@@ -59,7 +62,8 @@ static void mowgli_epoll_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_epoll_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_epoll_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_epoll_eventloop_private_t *priv;
 	struct epoll_event ep_event;
@@ -82,10 +86,12 @@ static void mowgli_epoll_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli
 	}
 }
 
-static void mowgli_epoll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_epoll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_epoll_eventloop_private_t *priv;
 	struct epoll_event ep_event;
+
 	int op = -1;
 	unsigned int old_flags;
 
@@ -95,9 +101,9 @@ static void mowgli_epoll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 	priv = eventloop->poller;
 	old_flags = pollable->slot;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	switch (dir)
 	{
@@ -114,9 +120,9 @@ static void mowgli_epoll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 		break;
 	}
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	if (pollable->read_function == NULL)
 		pollable->slot &= ~EPOLLIN;
@@ -124,11 +130,11 @@ static void mowgli_epoll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 	if (pollable->write_function == NULL)
 		pollable->slot &= ~EPOLLOUT;
 
-	if (old_flags == 0 && pollable->slot == 0)
+	if ((old_flags == 0) && (pollable->slot == 0))
 		return;
 	else if (pollable->slot <= 0)
 		op = EPOLL_CTL_DEL;
-	else if (old_flags == 0 && pollable->slot != 0)
+	else if ((old_flags == 0) && (pollable->slot != 0))
 		op = EPOLL_CTL_ADD;
 	else if (pollable->slot != old_flags)
 		op = EPOLL_CTL_MOD;
@@ -150,7 +156,8 @@ static void mowgli_epoll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 	return;
 }
 
-static void mowgli_epoll_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
+static void
+mowgli_epoll_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
 {
 	mowgli_epoll_eventloop_private_t *priv;
 	int i, num, o_errno;
@@ -177,15 +184,16 @@ static void mowgli_epoll_eventloop_select(mowgli_eventloop_t *eventloop, int del
 	{
 		mowgli_eventloop_pollable_t *pollable = priv->pfd[i].data.ptr;
 
-		if (priv->pfd[i].events & (EPOLLIN | EPOLLHUP | EPOLLERR) && pollable->read_function != NULL)
-			pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+		if (priv->pfd[i].events & (EPOLLIN | EPOLLHUP | EPOLLERR))
+			mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
 
-		if (priv->pfd[i].events & (EPOLLOUT | EPOLLHUP | EPOLLERR) && pollable->write_function != NULL)
-			pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+		if (priv->pfd[i].events & (EPOLLOUT | EPOLLHUP | EPOLLERR))
+			mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 	}
 }
 
-mowgli_eventloop_ops_t _mowgli_epoll_pollops = {
+mowgli_eventloop_ops_t _mowgli_epoll_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_epoll_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/eventloop.c b/src/libmowgli/eventloop/eventloop.c
index d2045cd..d8eb422 100644
--- a/src/libmowgli/eventloop/eventloop.c
+++ b/src/libmowgli/eventloop/eventloop.c
@@ -46,7 +46,8 @@ extern mowgli_eventloop_ops_t _mowgli_kqueue_pollops;
 extern mowgli_eventloop_ops_t _mowgli_winsock_pollops;
 #endif
 
-mowgli_eventloop_t *mowgli_eventloop_create(void)
+mowgli_eventloop_t *
+mowgli_eventloop_create(void)
 {
 	mowgli_eventloop_t *eventloop;
 
@@ -81,18 +82,21 @@ mowgli_eventloop_t *mowgli_eventloop_create(void)
 
 	if (mowgli_mutex_init(&eventloop->mutex) != 0)
 	{
-		mowgli_log("couldn't create mutex for eventloop %p, aborting...", eventloop);
+		mowgli_log("couldn't create mutex for eventloop %p, aborting...", (void *) eventloop);
 		abort();
 	}
 
 	eventloop->eventloop_ops->pollsetup(eventloop);
 
-	mowgli_eventloop_synchronize(eventloop);
+	eventloop->deadline = -1;
+
+	mowgli_eventloop_calibrate(eventloop);
 
 	return eventloop;
 }
 
-void mowgli_eventloop_destroy(mowgli_eventloop_t *eventloop)
+void
+mowgli_eventloop_destroy(mowgli_eventloop_t *eventloop)
 {
 	eventloop->eventloop_ops->pollshutdown(eventloop);
 
@@ -100,7 +104,8 @@ void mowgli_eventloop_destroy(mowgli_eventloop_t *eventloop)
 	mowgli_heap_free(eventloop_heap, eventloop);
 }
 
-void mowgli_eventloop_run(mowgli_eventloop_t *eventloop)
+void
+mowgli_eventloop_run(mowgli_eventloop_t *eventloop)
 {
 	return_if_fail(eventloop != NULL);
 
@@ -109,12 +114,15 @@ void mowgli_eventloop_run(mowgli_eventloop_t *eventloop)
 	eventloop->death_requested = false;
 
 	while (!eventloop->death_requested)
+	{
 		eventloop->eventloop_ops->run_once(eventloop);
+	}
 
 	mowgli_mutex_unlock(&eventloop->mutex);
 }
 
-void mowgli_eventloop_run_once(mowgli_eventloop_t *eventloop)
+void
+mowgli_eventloop_run_once(mowgli_eventloop_t *eventloop)
 {
 	return_if_fail(eventloop != NULL);
 
@@ -125,7 +133,8 @@ void mowgli_eventloop_run_once(mowgli_eventloop_t *eventloop)
 	mowgli_mutex_unlock(&eventloop->mutex);
 }
 
-void mowgli_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int timeout)
+void
+mowgli_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int timeout)
 {
 	return_if_fail(eventloop != NULL);
 
@@ -139,7 +148,8 @@ void mowgli_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int timeout)
 	mowgli_mutex_unlock(&eventloop->mutex);
 }
 
-void mowgli_eventloop_break(mowgli_eventloop_t *eventloop)
+void
+mowgli_eventloop_break(mowgli_eventloop_t *eventloop)
 {
 	return_if_fail(eventloop != NULL);
 
@@ -147,7 +157,8 @@ void mowgli_eventloop_break(mowgli_eventloop_t *eventloop)
 }
 
 /* convenience function to request null pollops */
-void mowgli_eventloop_timers_only(mowgli_eventloop_t *eventloop)
+void
+mowgli_eventloop_timers_only(mowgli_eventloop_t *eventloop)
 {
 	return_if_fail(eventloop != NULL);
 
@@ -155,14 +166,16 @@ void mowgli_eventloop_timers_only(mowgli_eventloop_t *eventloop)
 }
 
 /* userdata setting/getting functions (for bindings) */
-void *mowgli_eventloop_get_data(mowgli_eventloop_t *eventloop)
+void *
+mowgli_eventloop_get_data(mowgli_eventloop_t *eventloop)
 {
 	return_val_if_fail(eventloop != NULL, NULL);
 
 	return eventloop->data;
 }
 
-void mowgli_eventloop_set_data(mowgli_eventloop_t *eventloop, void *data)
+void
+mowgli_eventloop_set_data(mowgli_eventloop_t *eventloop, void *data)
 {
 	return_if_fail(eventloop != NULL);
 
diff --git a/src/libmowgli/eventloop/eventloop.h b/src/libmowgli/eventloop/eventloop.h
index 4c07b27..42a257c 100644
--- a/src/libmowgli/eventloop/eventloop.h
+++ b/src/libmowgli/eventloop/eventloop.h
@@ -21,6 +21,13 @@
 #ifndef __MOWGLI_EVENTLOOP_EVENTLOOP_H__
 #define __MOWGLI_EVENTLOOP_EVENTLOOP_H__
 
+#ifdef MOWGLI_OS_OSX
+
+# include <mach/mach.h>
+# include <mach/mach_time.h>
+
+#endif
+
 #ifndef _WIN32
 
 typedef int mowgli_descriptor_t;
@@ -31,13 +38,15 @@ typedef SOCKET mowgli_descriptor_t;
 
 #endif
 
-typedef enum {
+typedef enum
+{
 	MOWGLI_EVENTLOOP_TYPE_POLLABLE,
 	MOWGLI_EVENTLOOP_TYPE_HELPER,
 	MOWGLI_EVENTLOOP_TYPE_ERROR = -1
 } mowgli_eventloop_io_type_t;
 
-typedef struct {
+typedef struct
+{
 	mowgli_eventloop_io_type_t type;
 } mowgli_eventloop_io_obj_t;
 
@@ -48,7 +57,8 @@ typedef struct _mowgli_helper mowgli_eventloop_helper_proc_t;
 
 typedef struct _mowgli_linebuf mowgli_linebuf_t;
 
-typedef enum {
+typedef enum
+{
 	MOWGLI_EVENTLOOP_IO_READ,
 	MOWGLI_EVENTLOOP_IO_WRITE,
 	MOWGLI_EVENTLOOP_IO_ERROR = -1
@@ -57,7 +67,8 @@ typedef enum {
 typedef void mowgli_eventloop_io_t;
 
 /* checked casts */
-static inline mowgli_eventloop_pollable_t *mowgli_eventloop_io_pollable(mowgli_eventloop_io_t *io)
+static inline mowgli_eventloop_pollable_t *
+mowgli_eventloop_io_pollable(mowgli_eventloop_io_t *io)
 {
 	mowgli_eventloop_io_obj_t *obj = (mowgli_eventloop_io_obj_t *) io;
 
@@ -67,7 +78,8 @@ static inline mowgli_eventloop_pollable_t *mowgli_eventloop_io_pollable(mowgli_e
 	return (mowgli_eventloop_pollable_t *) io;
 }
 
-static inline mowgli_eventloop_helper_proc_t *mowgli_eventloop_io_helper(mowgli_eventloop_io_t *io)
+static inline mowgli_eventloop_helper_proc_t *
+mowgli_eventloop_io_helper(mowgli_eventloop_io_t *io)
 {
 	mowgli_eventloop_io_obj_t *obj = (mowgli_eventloop_io_obj_t *) io;
 
@@ -77,7 +89,8 @@ static inline mowgli_eventloop_helper_proc_t *mowgli_eventloop_io_helper(mowgli_
 	return (mowgli_eventloop_helper_proc_t *) io;
 }
 
-static inline mowgli_eventloop_io_type_t mowgli_eventloop_io_type(mowgli_eventloop_io_t *io)
+static inline mowgli_eventloop_io_type_t
+mowgli_eventloop_io_type(mowgli_eventloop_io_t *io)
 {
 	mowgli_eventloop_io_obj_t *obj = (mowgli_eventloop_io_obj_t *) io;
 
@@ -86,9 +99,10 @@ static inline mowgli_eventloop_io_type_t mowgli_eventloop_io_type(mowgli_eventlo
 	return obj->type;
 }
 
-typedef void mowgli_eventloop_io_cb_t(mowgli_eventloop_t *eventloop, mowgli_eventloop_io_t *io, mowgli_eventloop_io_dir_t dir, void *userdata);
+typedef void mowgli_eventloop_io_cb_t (mowgli_eventloop_t * eventloop, mowgli_eventloop_io_t * io, mowgli_eventloop_io_dir_t dir, void *userdata);
 
-struct _mowgli_pollable {
+struct _mowgli_pollable
+{
 	mowgli_eventloop_io_obj_t type;
 
 	mowgli_descriptor_t fd;
@@ -106,7 +120,8 @@ struct _mowgli_pollable {
 	mowgli_eventloop_t *eventloop;
 };
 
-typedef struct {
+typedef struct
+{
 	void (*timeout_once)(mowgli_eventloop_t *eventloop, int timeout);
 	void (*run_once)(mowgli_eventloop_t *eventloop);
 	void (*pollsetup)(mowgli_eventloop_t *eventloop);
@@ -116,7 +131,8 @@ typedef struct {
 	void (*destroy)(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable);
 } mowgli_eventloop_ops_t;
 
-struct _mowgli_eventloop {
+struct _mowgli_eventloop
+{
 	time_t currtime;
 	time_t deadline;
 
@@ -131,41 +147,124 @@ struct _mowgli_eventloop {
 	bool death_requested;
 
 	void *data;
+
+	time_t epochbias;
 };
 
-typedef void mowgli_event_dispatch_func_t(void *userdata);
+typedef void mowgli_event_dispatch_func_t (void *userdata);
 
-typedef struct {
+typedef struct
+{
 	mowgli_node_t node;
 
 	mowgli_event_dispatch_func_t *func;
 	void *arg;
 	const char *name;
 	time_t frequency;
-	time_t when;
+	time_t deadline;
 	bool active;
 } mowgli_eventloop_timer_t;
 
-static inline void mowgli_eventloop_set_time(mowgli_eventloop_t *eventloop, time_t newtime)
+static inline void
+mowgli_eventloop_set_time(mowgli_eventloop_t *eventloop, time_t newtime)
 {
 	return_if_fail(eventloop != NULL);
 
 	eventloop->currtime = newtime;
 }
 
-static inline time_t mowgli_eventloop_get_time(mowgli_eventloop_t *eventloop)
+static inline time_t
+mowgli_eventloop_get_time(mowgli_eventloop_t *eventloop)
 {
 	return_val_if_fail(eventloop != NULL, 0);
 
-	return eventloop->currtime;
+	return eventloop->epochbias + eventloop->currtime;
 }
 
-static inline void mowgli_eventloop_synchronize(mowgli_eventloop_t *eventloop)
+static inline void
+mowgli_eventloop_synchronize(mowgli_eventloop_t *eventloop)
 {
-	mowgli_eventloop_set_time(eventloop, time(NULL));
+	long long time_;
+
+#if defined(CLOCK_MONOTONIC)
+	struct timespec tp;
+
+	clock_gettime(CLOCK_MONOTONIC, &tp);
+	time_ = tp.tv_sec;
+#elif defined(CLOCK_HIGHRES)
+	struct timespec tp;
+
+	clock_gettime(CLOCK_HIGHRES, &tp);
+	time_ = tp.tv_sec;
+#elif defined(MOWGLI_OS_WIN)
+	static ULONGLONG (CALLBACK *GetTickCount64)(void) = NULL;
+	static OSVERSIONINFOEX *winver = NULL;
+	static bool load_err = false;
+
+	if (winver == NULL)
+	{
+		winver = mowgli_alloc(sizeof(OSVERSIONINFOEX));
+		winver->dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+
+		if (!GetVersionEx((OSVERSIONINFO *) winver))
+		{
+			mowgli_free(winver);
+			winver = NULL;	/* FIXME */
+		}
+	}
+
+	if (winver && (winver->dwMajorVersion >= 6))
+	{
+		if ((GetTickCount64 == NULL) && !load_err)
+		{
+			HINSTANCE hKernel32;
+
+			hKernel32 = GetModuleHandle("KERNEL32");
+			GetTickCount64 = GetProcAddress(hKernel32, "GetTickCount64");
+
+			if (GetTickCount64 == NULL)
+				load_err = true;
+		}
+
+		if (load_err)
+		{
+			time_ = time(NULL);
+		}
+		else
+		{
+			soft_assert(GetTickCount64 != NULL);
+
+			time_ = (int) (GetTickCount64() * 1e-3);
+		}
+	}
+	else
+	{
+		time_ = time(NULL);
+	}
+
+#elif defined(MOWGLI_OS_OSX)
+	static mach_timebase_info_data_t timebase;
+
+	if (timebase.denom == 0)
+		mach_timebase_info(&timebase);
+
+	time_ = (int) (mach_absolute_time() * timebase.numer / timebase.denom * 1e-9);
+#else
+	time_ = time(NULL);
+#endif
+	mowgli_eventloop_set_time(eventloop, (time_t) time_);
+}
+
+/* Sets the bias of eventloop->currtime relative to Jan 1 00:00:00 1970 */
+static inline void
+mowgli_eventloop_calibrate(mowgli_eventloop_t *eventloop)
+{
+	mowgli_eventloop_synchronize(eventloop);
+	eventloop->epochbias = time(NULL) - eventloop->currtime;
 }
 
-static inline bool mowgli_eventloop_ignore_errno(int error)
+static inline bool
+mowgli_eventloop_ignore_errno(int error)
 {
 	switch (error)
 	{
@@ -178,6 +277,9 @@ static inline bool mowgli_eventloop_ignore_errno(int error)
 #if defined(EAGAIN) && (EWOULDBLOCK != EAGAIN)
 	case EAGAIN:
 #endif
+#ifdef ETIME
+	case ETIME:
+#endif
 #ifdef EINTR
 	case EINTR:
 #endif
@@ -198,9 +300,10 @@ static inline bool mowgli_eventloop_ignore_errno(int error)
 	return false;
 }
 
-typedef void mowgli_eventloop_helper_start_fn_t(mowgli_eventloop_helper_proc_t *helper, void *userdata);
+typedef void mowgli_eventloop_helper_start_fn_t (mowgli_eventloop_helper_proc_t * helper, void *userdata);
 
-struct _mowgli_helper {
+struct _mowgli_helper
+{
 	mowgli_eventloop_io_obj_t type;
 
 	mowgli_process_t *child;
@@ -254,6 +357,7 @@ extern mowgli_eventloop_pollable_t *mowgli_pollable_create(mowgli_eventloop_t *e
 extern void mowgli_pollable_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable);
 extern void mowgli_pollable_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function);
 extern void mowgli_pollable_set_nonblocking(mowgli_eventloop_pollable_t *pollable, bool nonblocking);
+extern void mowgli_pollable_set_cloexec(mowgli_eventloop_pollable_t *pollable, bool cloexec);
+extern void mowgli_pollable_trigger(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir);
 
 #endif
-
diff --git a/src/libmowgli/eventloop/helper.c b/src/libmowgli/eventloop/helper.c
index b89e447..5acc5f0 100644
--- a/src/libmowgli/eventloop/helper.c
+++ b/src/libmowgli/eventloop/helper.c
@@ -20,7 +20,8 @@
 
 #include "mowgli.h"
 
-typedef struct {
+typedef struct
+{
 	mowgli_eventloop_helper_start_fn_t *start_fn;
 	void *userdata;
 	mowgli_descriptor_t fd;
@@ -30,6 +31,7 @@ static void
 mowgli_helper_trampoline(mowgli_helper_create_req_t *req)
 {
 	mowgli_eventloop_helper_proc_t *helper;
+
 #ifndef _WIN32
 	int i, x;
 #endif
@@ -42,22 +44,20 @@ mowgli_helper_trampoline(mowgli_helper_create_req_t *req)
 	helper->fd = req->fd;
 
 #ifndef _WIN32
+
 	for (i = 0; i < 1024; i++)
-	{
 		if (i != req->fd)
 			close(i);
-	}
 
 	x = open("/dev/null", O_RDWR);
 
 	for (i = 0; i < 2; i++)
-	{
 		if (req->fd != i)
 			dup2(x, i);
-	}
 
 	if (x > 2)
 		close(x);
+
 #endif
 
 	helper->eventloop = mowgli_eventloop_create();
@@ -194,10 +194,16 @@ mowgli_helper_io_trampoline(mowgli_eventloop_t *eventloop, mowgli_eventloop_io_t
 {
 	mowgli_eventloop_helper_proc_t *helper = userdata;
 
-	switch (dir) {
+	switch (dir)
+	{
 	case MOWGLI_EVENTLOOP_IO_READ:
+
 		if (helper->read_function != NULL)
-			return helper->read_function(eventloop, helper, MOWGLI_EVENTLOOP_IO_READ, helper->userdata);
+		{
+			helper->read_function(eventloop, helper, MOWGLI_EVENTLOOP_IO_READ, helper->userdata);
+			return;
+		}
+
 	default:
 		break;
 	}
diff --git a/src/libmowgli/eventloop/kqueue_pollops.c b/src/libmowgli/eventloop/kqueue_pollops.c
index 7bfa2bb..113d7b3 100644
--- a/src/libmowgli/eventloop/kqueue_pollops.c
+++ b/src/libmowgli/eventloop/kqueue_pollops.c
@@ -23,15 +23,17 @@
 
 #ifdef HAVE_KQUEUE
 
-#include <sys/event.h>
+# include <sys/event.h>
 
-typedef struct {
+typedef struct
+{
 	int kqueue_fd;
 	int nevents;
 	struct kevent *events;
 } mowgli_kqueue_eventloop_private_t;
 
-static void mowgli_kqueue_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_kqueue_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	mowgli_kqueue_eventloop_private_t *priv;
 
@@ -42,10 +44,14 @@ static void mowgli_kqueue_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	priv->kqueue_fd = kqueue();
 	priv->events = mowgli_alloc(sizeof(struct kevent) * priv->nevents);
 
+	/* attempt to set the fd as close-on-exec, but ignore errors */
+	fcntl(priv->kqueue_fd, F_SETFD, FD_CLOEXEC);
+
 	return;
 }
 
-static void mowgli_kqueue_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_kqueue_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	mowgli_kqueue_eventloop_private_t *priv;
 
@@ -60,7 +66,8 @@ static void mowgli_kqueue_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_kqueue_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_kqueue_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_kqueue_eventloop_private_t *priv;
 	struct kevent event;
@@ -71,19 +78,20 @@ static void mowgli_kqueue_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgl
 	priv = eventloop->poller;
 
 	EV_SET(&event, pollable->fd, EVFILT_READ | EVFILT_WRITE, EV_DELETE, 0, 0, pollable);
+
 	if (kevent(priv->kqueue_fd, &event, 1, NULL, 0,
-			&(const struct timespec){ .tv_sec = 0, .tv_nsec = 0}
-			) != 0)
-	{
+		   &(const struct timespec) { .tv_sec = 0, .tv_nsec = 0 }
+		   ) != 0)
 		mowgli_log("mowgli_kqueue_eventloop_setselect(): kevent failed: %d (%s)", errno, strerror(errno));
-	}
 }
 
-static void mowgli_kqueue_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_kqueue_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_kqueue_eventloop_private_t *priv;
 	mowgli_eventloop_io_cb_t **fptr;
 	struct kevent event;
+
 	int filter;
 	bool change;
 
@@ -93,9 +101,9 @@ static void mowgli_kqueue_eventloop_setselect(mowgli_eventloop_t *eventloop, mow
 	priv = eventloop->poller;
 	change = false;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	switch (dir)
 	{
@@ -119,21 +127,21 @@ static void mowgli_kqueue_eventloop_setselect(mowgli_eventloop_t *eventloop, mow
 	if (!change)
 		return;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	EV_SET(&event, pollable->fd, filter,
-			event_function ? EV_ADD : EV_DELETE, 0, 0, pollable);
+	       event_function ? EV_ADD : EV_DELETE, 0, 0, pollable);
+
 	if (kevent(priv->kqueue_fd, &event, 1, NULL, 0,
-			&(const struct timespec){ .tv_sec = 0, .tv_nsec = 0}
-			) != 0)
-	{
+		   &(const struct timespec) { .tv_sec = 0, .tv_nsec = 0 }
+		   ) != 0)
 		mowgli_log("mowgli_kqueue_eventloop_setselect(): kevent failed: %d (%s)", errno, strerror(errno));
-	}
 }
 
-static void mowgli_kqueue_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
+static void
+mowgli_kqueue_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
 {
 	mowgli_kqueue_eventloop_private_t *priv;
 	int i, num, o_errno;
@@ -143,8 +151,8 @@ static void mowgli_kqueue_eventloop_select(mowgli_eventloop_t *eventloop, int de
 	priv = eventloop->poller;
 
 	num = kevent(priv->kqueue_fd, NULL, 0, priv->events, priv->nevents,
-			delay >= 0 ? &(const struct timespec){ .tv_sec = delay / 1000,
-			.tv_nsec = delay % 1000 * 1000000 } : NULL);
+		     delay >= 0 ? &(const struct timespec) { .tv_sec = delay / 1000,
+							     .tv_nsec = delay % 1000 * 1000000 } : NULL);
 
 	o_errno = errno;
 	mowgli_eventloop_synchronize(eventloop);
@@ -162,13 +170,11 @@ static void mowgli_kqueue_eventloop_select(mowgli_eventloop_t *eventloop, int de
 	{
 		mowgli_eventloop_pollable_t *pollable = priv->events[i].udata;
 
-		if (priv->events[i].filter == EVFILT_READ &&
-				pollable->read_function != NULL)
-			pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+		if (priv->events[i].filter == EVFILT_READ)
+			mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
 
-		if (priv->events[i].filter == EVFILT_WRITE &&
-				pollable->write_function != NULL)
-			pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+		if (priv->events[i].filter == EVFILT_WRITE)
+			mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 
 		/* XXX Perhaps we need to recheck read_function and
 		 * write_function now.
@@ -176,7 +182,8 @@ static void mowgli_kqueue_eventloop_select(mowgli_eventloop_t *eventloop, int de
 	}
 }
 
-mowgli_eventloop_ops_t _mowgli_kqueue_pollops = {
+mowgli_eventloop_ops_t _mowgli_kqueue_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_kqueue_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/null_pollops.c b/src/libmowgli/eventloop/null_pollops.c
index 8fcabe4..7788aec 100644
--- a/src/libmowgli/eventloop/null_pollops.c
+++ b/src/libmowgli/eventloop/null_pollops.c
@@ -20,7 +20,8 @@
 
 #include "mowgli.h"
 
-void mowgli_simple_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int timeout)
+void
+mowgli_simple_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int timeout)
 {
 	time_t delay, currtime;
 	int t;
@@ -33,7 +34,7 @@ void mowgli_simple_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int tim
 	currtime = mowgli_eventloop_get_time(eventloop);
 	delay = mowgli_eventloop_next_timer(eventloop);
 
-	if (delay <= currtime)
+	while (delay != -1 && delay <= currtime)
 	{
 		mowgli_eventloop_run_timers(eventloop);
 		mowgli_eventloop_synchronize(eventloop);
@@ -44,28 +45,26 @@ void mowgli_simple_eventloop_timeout_once(mowgli_eventloop_t *eventloop, int tim
 
 	if (timeout)
 		t = timeout;
+	else if (delay == -1)
+		t = 5000; /* arbitrary 5 second default timeout */
 	else
-	{
-		if (delay <= currtime)
-			t = -1;
-		else
-			t = (delay - currtime) * 1000;
-	}
+		t = (delay - currtime) * 1000;
 
 #ifdef DEBUG
 	mowgli_log("delay: %ld, currtime: %ld, select period: %d", delay, currtime, t);
 #endif
 
 	eventloop->eventloop_ops->select(eventloop, t);
-
 }
 
-void mowgli_simple_eventloop_run_once(mowgli_eventloop_t *eventloop)
+void
+mowgli_simple_eventloop_run_once(mowgli_eventloop_t *eventloop)
 {
 	eventloop->eventloop_ops->timeout_once(eventloop, 0);
 }
 
-void mowgli_simple_eventloop_error_handler(mowgli_eventloop_t *eventloop, mowgli_eventloop_io_t *io, mowgli_eventloop_io_dir_t dir, void *userdata)
+void
+mowgli_simple_eventloop_error_handler(mowgli_eventloop_t *eventloop, mowgli_eventloop_io_t *io, mowgli_eventloop_io_dir_t dir, void *userdata)
 {
 	mowgli_eventloop_pollable_t *pollable = mowgli_eventloop_io_pollable(io);
 
@@ -73,24 +72,28 @@ void mowgli_simple_eventloop_error_handler(mowgli_eventloop_t *eventloop, mowgli
 		mowgli_pollable_destroy(eventloop, pollable);
 }
 
-static void mowgli_null_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_null_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	return;
 }
 
-static void mowgli_null_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_null_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	return;
 }
 
-static void mowgli_null_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_null_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	return;
 }
 
-static void mowgli_null_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_null_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
-	mowgli_log("null eventloop does not really do polling, events for pollable<%p> will be ignored", pollable);
+	mowgli_log("null eventloop does not really do polling, events for pollable<%p> will be ignored", (void *) pollable);
 
 	switch (dir)
 	{
@@ -108,12 +111,16 @@ static void mowgli_null_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgl
 	return;
 }
 
-static void mowgli_null_eventloop_select(mowgli_eventloop_t *eventloop, int time)
+static void
+mowgli_null_eventloop_select(mowgli_eventloop_t *eventloop, int time)
 {
+	for (; time > 999999; time -= 999999)
+		usleep(999999);
 	usleep(time);
 }
 
-mowgli_eventloop_ops_t _mowgli_null_pollops = {
+mowgli_eventloop_ops_t _mowgli_null_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_null_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/poll_pollops.c b/src/libmowgli/eventloop/poll_pollops.c
index 0bea454..6c5d7e5 100644
--- a/src/libmowgli/eventloop/poll_pollops.c
+++ b/src/libmowgli/eventloop/poll_pollops.c
@@ -22,22 +22,25 @@
 
 #ifdef HAVE_POLL_H
 
-#include <poll.h>
+# include <poll.h>
 
-#ifndef POLLRDNORM
-#define POLLRDNORM POLLIN
-#endif
-#ifndef POLLWRNORM
-#define POLLWRNORM POLLOUT
-#endif
+# ifndef POLLRDNORM
+#  define POLLRDNORM POLLIN
+# endif
+# ifndef POLLWRNORM
+#  define POLLWRNORM POLLOUT
+# endif
 
-typedef struct {
+typedef struct
+{
 	struct pollfd pollfds[FD_SETSIZE];
+
 	nfds_t nfds;
 	mowgli_list_t pollable_list;
 } mowgli_poll_eventloop_private_t;
 
-static nfds_t update_poll_fds(mowgli_eventloop_t *eventloop)
+static nfds_t
+update_poll_fds(mowgli_eventloop_t *eventloop)
 {
 	mowgli_node_t *n, *tn;
 	mowgli_poll_eventloop_private_t *priv;
@@ -49,13 +52,13 @@ static nfds_t update_poll_fds(mowgli_eventloop_t *eventloop)
 
 	memset(priv->pollfds, '\0', sizeof(priv->pollfds));
 
-        MOWGLI_ITER_FOREACH_SAFE(n, tn, priv->pollable_list.head)
-        {
+	MOWGLI_ITER_FOREACH_SAFE(n, tn, priv->pollable_list.head)
+	{
 		mowgli_eventloop_pollable_t *pollable = n->data;
 
-#ifdef DEBUG
+# ifdef DEBUG
 		mowgli_log("considering fd %d pollable %p count %d", pollable->fd, pollable, priv->pollable_list.count);
-#endif
+# endif
 
 		if (pollable->read_function || pollable->write_function)
 		{
@@ -72,13 +75,16 @@ static nfds_t update_poll_fds(mowgli_eventloop_t *eventloop)
 			slot++;
 		}
 		else
+		{
 			pollable->slot = -1;
+		}
 	}
 
-        return slot;
+	return slot;
 }
 
-static void mowgli_poll_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_poll_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	mowgli_poll_eventloop_private_t *priv;
 
@@ -88,7 +94,8 @@ static void mowgli_poll_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_poll_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_poll_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	mowgli_node_t *n, *tn;
 	mowgli_poll_eventloop_private_t *priv;
@@ -106,7 +113,8 @@ static void mowgli_poll_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_poll_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_poll_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_poll_eventloop_private_t *priv;
 
@@ -118,7 +126,8 @@ static void mowgli_poll_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_
 	mowgli_node_delete(&pollable->node, &priv->pollable_list);
 }
 
-static void mowgli_poll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_poll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_poll_eventloop_private_t *priv;
 
@@ -127,9 +136,9 @@ static void mowgli_poll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgl
 
 	priv = eventloop->poller;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	if (pollable->read_function || pollable->write_function)
 		mowgli_node_delete(&pollable->node, &priv->pollable_list);
@@ -147,9 +156,9 @@ static void mowgli_poll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgl
 		break;
 	}
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	if (pollable->read_function || pollable->write_function)
 		mowgli_node_add(pollable, &pollable->node, &priv->pollable_list);
@@ -157,7 +166,8 @@ static void mowgli_poll_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgl
 	return;
 }
 
-static void mowgli_poll_eventloop_select(mowgli_eventloop_t *eventloop, int time)
+static void
+mowgli_poll_eventloop_select(mowgli_eventloop_t *eventloop, int time)
 {
 	mowgli_node_t *n, *tn;
 	nfds_t nfds;
@@ -181,17 +191,17 @@ static void mowgli_poll_eventloop_select(mowgli_eventloop_t *eventloop, int time
 			pollable = n->data;
 			slot = pollable->slot;
 
-			if (slot == -1 || priv->pollfds[slot].revents == 0)
+			if ((slot == -1) || (priv->pollfds[slot].revents == 0))
 				continue;
 
 			if (priv->pollfds[slot].revents & (POLLRDNORM | POLLIN | POLLHUP | POLLERR) && pollable->read_function)
 			{
-#ifdef DEBUG
+# ifdef DEBUG
 				mowgli_log("run %p(%p, %p, MOWGLI_EVENTLOOP_IO_READ, %p)\n", pollable->read_function, eventloop, pollable, pollable->userdata);
-#endif
+# endif
 
 				priv->pollfds[slot].events &= ~(POLLRDNORM | POLLIN);
-				pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+				mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
 			}
 		}
 
@@ -200,23 +210,24 @@ static void mowgli_poll_eventloop_select(mowgli_eventloop_t *eventloop, int time
 			pollable = n->data;
 			slot = pollable->slot;
 
-			if (slot == -1 || priv->pollfds[slot].revents == 0)
+			if ((slot == -1) || (priv->pollfds[slot].revents == 0))
 				continue;
 
 			if (priv->pollfds[slot].revents & (POLLWRNORM | POLLOUT | POLLHUP | POLLERR) && pollable->write_function)
 			{
-#ifdef DEBUG
+# ifdef DEBUG
 				mowgli_log("run %p(%p, %p, MOWGLI_EVENTLOOP_IO_WRITE, %p)\n", pollable->write_function, eventloop, pollable, pollable->userdata);
-#endif
+# endif
 
 				priv->pollfds[slot].events &= ~(POLLWRNORM | POLLOUT);
-				pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+				mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 			}
 		}
 	}
 }
 
-mowgli_eventloop_ops_t _mowgli_poll_pollops = {
+mowgli_eventloop_ops_t _mowgli_poll_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_poll_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/pollable.c b/src/libmowgli/eventloop/pollable.c
index e2c2e2a..5f9526e 100644
--- a/src/libmowgli/eventloop/pollable.c
+++ b/src/libmowgli/eventloop/pollable.c
@@ -22,7 +22,8 @@
 
 static mowgli_heap_t *pollable_heap = NULL;
 
-mowgli_eventloop_pollable_t *mowgli_pollable_create(mowgli_eventloop_t *eventloop, mowgli_descriptor_t fd, void *userdata)
+mowgli_eventloop_pollable_t *
+mowgli_pollable_create(mowgli_eventloop_t *eventloop, mowgli_descriptor_t fd, void *userdata)
 {
 	mowgli_eventloop_pollable_t *pollable;
 
@@ -41,7 +42,8 @@ mowgli_eventloop_pollable_t *mowgli_pollable_create(mowgli_eventloop_t *eventloo
 	return pollable;
 }
 
-void mowgli_pollable_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+void
+mowgli_pollable_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	return_if_fail(eventloop != NULL);
 	return_if_fail(pollable != NULL);
@@ -52,7 +54,8 @@ void mowgli_pollable_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pol
 	mowgli_heap_free(pollable_heap, pollable);
 }
 
-void mowgli_pollable_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+void
+mowgli_pollable_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	return_if_fail(eventloop != NULL);
 	return_if_fail(pollable != NULL);
@@ -61,7 +64,8 @@ void mowgli_pollable_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_p
 	eventloop->eventloop_ops->setselect(eventloop, pollable, dir, event_function);
 }
 
-void mowgli_pollable_set_nonblocking(mowgli_eventloop_pollable_t *pollable, bool nonblocking)
+void
+mowgli_pollable_set_nonblocking(mowgli_eventloop_pollable_t *pollable, bool nonblocking)
 {
 #if defined(HAVE_FCNTL)
 	unsigned long flags;
@@ -86,3 +90,53 @@ void mowgli_pollable_set_nonblocking(mowgli_eventloop_pollable_t *pollable, bool
 	ioctlsocket(pollable->fd, FIONBIO, &mode);
 #endif
 }
+
+void
+mowgli_pollable_set_cloexec(mowgli_eventloop_pollable_t *pollable, bool cloexec)
+{
+#if defined(FD_CLOEXEC)
+	unsigned long flags;
+
+	return_if_fail(pollable != NULL);
+
+	flags = fcntl(pollable->fd, F_GETFD);
+
+	if (cloexec)
+		flags |= FD_CLOEXEC;
+	else
+		flags &= ~FD_CLOEXEC;
+
+	fcntl(pollable->fd, F_SETFD, flags);
+#elif defined(HAVE_WINSOCK2_H)
+	return_if_fail(pollable != NULL);
+
+	SetHandleInformation((HANDLE)pollable->fd, HANDLE_FLAG_INHERIT, !cloexec);
+#endif
+}
+
+void
+mowgli_pollable_trigger(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir)
+{
+	mowgli_eventloop_io_cb_t *event_function;
+
+	return_if_fail(eventloop != NULL);
+	return_if_fail(pollable != NULL);
+
+	switch (dir)
+	{
+	case MOWGLI_EVENTLOOP_IO_READ:
+		event_function = pollable->read_function;
+		break;
+	case MOWGLI_EVENTLOOP_IO_WRITE:
+		event_function = pollable->write_function;
+		break;
+	default:
+		event_function = NULL;
+		return;
+	}
+
+	if (event_function == NULL)
+		return;
+
+	event_function(eventloop, pollable, dir, pollable->userdata);
+}
diff --git a/src/libmowgli/eventloop/ports_pollops.c b/src/libmowgli/eventloop/ports_pollops.c
index bc838da..0c68fd5 100644
--- a/src/libmowgli/eventloop/ports_pollops.c
+++ b/src/libmowgli/eventloop/ports_pollops.c
@@ -22,15 +22,17 @@
 
 #ifdef HAVE_PORT_CREATE
 
-#include <port.h>
+# include <port.h>
 
-typedef struct {
+typedef struct
+{
 	int port_fd;
 	int pfd_size;
 	port_event_t *pfd;
 } mowgli_ports_eventloop_private_t;
 
-static void mowgli_ports_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_ports_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	mowgli_ports_eventloop_private_t *priv;
 
@@ -44,7 +46,8 @@ static void mowgli_ports_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_ports_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_ports_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	mowgli_ports_eventloop_private_t *priv;
 
@@ -59,7 +62,8 @@ static void mowgli_ports_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_ports_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_ports_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_ports_eventloop_private_t *priv;
 
@@ -78,7 +82,8 @@ static void mowgli_ports_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli
 	}
 }
 
-static void mowgli_ports_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_ports_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_ports_eventloop_private_t *priv;
 	unsigned int old_flags;
@@ -89,9 +94,9 @@ static void mowgli_ports_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 	priv = eventloop->poller;
 	old_flags = pollable->slot;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	switch (dir)
 	{
@@ -108,9 +113,9 @@ static void mowgli_ports_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 		break;
 	}
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	if (pollable->read_function == NULL)
 		pollable->slot &= ~POLLIN;
@@ -118,8 +123,10 @@ static void mowgli_ports_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 	if (pollable->write_function == NULL)
 		pollable->slot &= ~POLLOUT;
 
-	if (old_flags == 0 && pollable->slot == 0)
+	if ((old_flags == 0) && (pollable->slot == 0))
+	{
 		return;
+	}
 	else if (pollable->slot == 0)
 	{
 		port_dissociate(priv->port_fd, PORT_SOURCE_FD, (uintptr_t) pollable->fd);
@@ -137,24 +144,25 @@ static void mowgli_ports_eventloop_setselect(mowgli_eventloop_t *eventloop, mowg
 	return;
 }
 
-static void mowgli_ports_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
+static void
+mowgli_ports_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
 {
 	mowgli_ports_eventloop_private_t *priv;
-	int i, num, o_errno, nget = 1;
+	int i, ret, o_errno, nget = 1;
 
 	return_if_fail(eventloop != NULL);
 
 	priv = eventloop->poller;
 
-	num = port_getn(priv->port_fd, priv->pfd, priv->pfd_size, &nget,
-			delay >= 0 ? &(struct timespec){ .tv_sec = delay / 1000, .tv_nsec = delay % 1000 * 1000000 } : NULL);
+	ret = port_getn(priv->port_fd, priv->pfd, priv->pfd_size, &nget,
+			delay >= 0 ? &(struct timespec) { .tv_sec = delay / 1000, .tv_nsec = delay % 1000 * 1000000 } : NULL);
 
 	o_errno = errno;
 	mowgli_eventloop_synchronize(eventloop);
 
-	if (num < 0)
+	if (ret == -1)
 	{
-		if (mowgli_eventloop_ignore_errno(errno))
+		if (mowgli_eventloop_ignore_errno(o_errno))
 			return;
 
 		mowgli_log("mowgli_ports_eventloop_select(): port_getn failed: %d (%s)", o_errno, strerror(o_errno));
@@ -165,15 +173,19 @@ static void mowgli_ports_eventloop_select(mowgli_eventloop_t *eventloop, int del
 	{
 		mowgli_eventloop_pollable_t *pollable = priv->pfd[i].portev_user;
 
-		if (priv->pfd[i].portev_events & (POLLIN | POLLHUP | POLLERR) && pollable->read_function != NULL)
-			pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+		if (priv->pfd[i].portev_source != PORT_SOURCE_FD)
+			continue;
 
-		if (priv->pfd[i].portev_events & (POLLOUT | POLLHUP | POLLERR) && pollable->write_function != NULL)
-			pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+		if (priv->pfd[i].portev_events & (POLLIN | POLLHUP | POLLERR))
+			mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
+
+		if (priv->pfd[i].portev_events & (POLLOUT | POLLHUP | POLLERR))
+			mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 	}
 }
 
-mowgli_eventloop_ops_t _mowgli_ports_pollops = {
+mowgli_eventloop_ops_t _mowgli_ports_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_ports_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/qnx_pollops.c b/src/libmowgli/eventloop/qnx_pollops.c
index 7417ef4..6c114d5 100644
--- a/src/libmowgli/eventloop/qnx_pollops.c
+++ b/src/libmowgli/eventloop/qnx_pollops.c
@@ -22,15 +22,17 @@
 
 #ifdef HAVE_DISPATCH_BLOCK
 
-#include <sys/iofunc.h>
-#include <sys/dispatch.h>
+# include <sys/iofunc.h>
+# include <sys/dispatch.h>
 
-typedef struct {
+typedef struct
+{
 	dispatch_t *dpp;
 	dispatch_context_t *ctp;
 } mowgli_qnx_eventloop_private_t;
 
-static void mowgli_qnx_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_qnx_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	mowgli_qnx_eventloop_private_t *priv;
 
@@ -42,7 +44,8 @@ static void mowgli_qnx_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_qnx_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_qnx_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	mowgli_qnx_eventloop_private_t *priv;
 
@@ -59,7 +62,8 @@ static void mowgli_qnx_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_qnx_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_qnx_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_qnx_eventloop_private_t *priv;
 
@@ -77,7 +81,8 @@ static void mowgli_qnx_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_e
 	}
 }
 
-static void mowgli_qnx_eventloop_event_cb(select_context_t *ctp, mowgli_descriptor_t fd, unsigned int flags, void *userdata)
+static void
+mowgli_qnx_eventloop_event_cb(select_context_t *ctp, mowgli_descriptor_t fd, unsigned int flags, void *userdata)
 {
 	mowgli_eventloop_t *eventloop;
 	mowgli_eventloop_pollable_t *pollable;
@@ -91,16 +96,17 @@ static void mowgli_qnx_eventloop_event_cb(select_context_t *ctp, mowgli_descript
 	return_if_fail(eventloop != NULL);
 
 	if (flags & (SELECT_FLAG_READ | SELECT_FLAG_EXCEPT))
-		pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+		mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
 
 	if (flags & (SELECT_FLAG_WRITE | SELECT_FLAG_EXCEPT))
-		pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+		mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 }
 
-static void mowgli_qnx_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_qnx_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_qnx_eventloop_private_t *priv;
-	select_attr_t attr = {};
+	select_attr_t attr = { };
 	unsigned int old_flags;
 
 	return_if_fail(eventloop != NULL);
@@ -109,9 +115,9 @@ static void mowgli_qnx_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli
 	priv = eventloop->poller;
 	old_flags = pollable->slot;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	switch (dir)
 	{
@@ -128,9 +134,9 @@ static void mowgli_qnx_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli
 		break;
 	}
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	if (pollable->read_function == NULL)
 		pollable->slot &= ~SELECT_FLAG_READ;
@@ -138,14 +144,13 @@ static void mowgli_qnx_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli
 	if (pollable->write_function == NULL)
 		pollable->slot &= ~SELECT_FLAG_WRITE;
 
-	if (old_flags == 0 && pollable->slot == 0)
+	if ((old_flags == 0) && (pollable->slot == 0))
 		return;
 
 	if (old_flags)
 		select_detach(priv->dpp, pollable->fd);
 
 	if (pollable->slot)
-	{
 		if (select_attach(priv->dpp, &attr, pollable->fd, pollable->slot, mowgli_qnx_eventloop_event_cb, pollable) != 0)
 		{
 			if (mowgli_eventloop_ignore_errno(errno))
@@ -153,12 +158,12 @@ static void mowgli_qnx_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli
 
 			mowgli_log("mowgli_qnx_eventloop_setselect(): select_attach failed: %d (%s)", errno, strerror(errno));
 		}
-	}
 
 	return;
 }
 
-static void mowgli_qnx_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
+static void
+mowgli_qnx_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
 {
 	dispatch_context_t *new_ctp;
 	mowgli_qnx_eventloop_private_t *priv;
@@ -168,14 +173,16 @@ static void mowgli_qnx_eventloop_select(mowgli_eventloop_t *eventloop, int delay
 	priv = eventloop->poller;
 
 	/* set timeout if needed */
-	dispatch_timeout(priv->dpp, delay >= 0 ? &(struct timespec){ .tv_sec = delay / 1000, .tv_nsec = delay % 1000 * 1000000 } : NULL);
+	dispatch_timeout(priv->dpp, delay >= 0 ? &(struct timespec) { .tv_sec = delay / 1000, .tv_nsec = delay % 1000 * 1000000 } : NULL);
 
 	if (priv->ctp != NULL)
 		priv->ctp = dispatch_context_alloc(priv->dpp);
 
 	/* if dispatch_block returns non-NULL, priv->ctp may have been realloc()'d, NULL is error condition */
 	if ((new_ctp = dispatch_block(priv->ctp)) != NULL)
+	{
 		priv->ctp = new_ctp;
+	}
 	else
 	{
 		if (mowgli_eventloop_ignore_errno(errno))
@@ -187,7 +194,8 @@ static void mowgli_qnx_eventloop_select(mowgli_eventloop_t *eventloop, int delay
 	mowgli_eventloop_synchronize(eventloop);
 }
 
-mowgli_eventloop_ops_t _mowgli_qnx_pollops = {
+mowgli_eventloop_ops_t _mowgli_qnx_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_qnx_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/select_pollops.c b/src/libmowgli/eventloop/select_pollops.c
index 467b4f5..ee5a966 100644
--- a/src/libmowgli/eventloop/select_pollops.c
+++ b/src/libmowgli/eventloop/select_pollops.c
@@ -22,15 +22,17 @@
 
 #ifdef HAVE_SELECT
 
-#ifdef HAVE_SYS_SELECT_H
-# include <sys/select.h>
-#endif
+# ifdef HAVE_SYS_SELECT_H
+#  include <sys/select.h>
+# endif
 
-typedef struct {
+typedef struct
+{
 	mowgli_list_t pollable_list;
 } mowgli_select_eventloop_private_t;
 
-static void mowgli_select_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_select_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	mowgli_select_eventloop_private_t *priv;
 
@@ -40,7 +42,8 @@ static void mowgli_select_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_select_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_select_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	mowgli_node_t *n, *tn;
 	mowgli_select_eventloop_private_t *priv;
@@ -58,7 +61,8 @@ static void mowgli_select_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_select_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_select_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_select_eventloop_private_t *priv;
 
@@ -70,7 +74,8 @@ static void mowgli_select_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgl
 	mowgli_node_delete(&pollable->node, &priv->pollable_list);
 }
 
-static void mowgli_select_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_select_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_select_eventloop_private_t *priv;
 
@@ -79,9 +84,9 @@ static void mowgli_select_eventloop_setselect(mowgli_eventloop_t *eventloop, mow
 
 	priv = eventloop->poller;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	if (pollable->read_function || pollable->write_function)
 		mowgli_node_delete(&pollable->node, &priv->pollable_list);
@@ -99,9 +104,9 @@ static void mowgli_select_eventloop_setselect(mowgli_eventloop_t *eventloop, mow
 		break;
 	}
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	if (pollable->read_function || pollable->write_function)
 		mowgli_node_add(pollable, &pollable->node, &priv->pollable_list);
@@ -109,7 +114,8 @@ static void mowgli_select_eventloop_setselect(mowgli_eventloop_t *eventloop, mow
 	return;
 }
 
-static void mowgli_select_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
+static void
+mowgli_select_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
 {
 	mowgli_node_t *n, *tn;
 	mowgli_eventloop_pollable_t *pollable;
@@ -126,13 +132,13 @@ static void mowgli_select_eventloop_select(mowgli_eventloop_t *eventloop, int de
 	FD_ZERO(&wfds);
 	FD_ZERO(&efds);
 
-        MOWGLI_ITER_FOREACH_SAFE(n, tn, priv->pollable_list.head)
-        {
+	MOWGLI_ITER_FOREACH_SAFE(n, tn, priv->pollable_list.head)
+	{
 		mowgli_eventloop_pollable_t *pollable = n->data;
 
-#ifdef DEBUG
+# ifdef DEBUG
 		mowgli_log("considering fd %d pollable %p count %d", pollable->fd, pollable, priv->pollable_list.count);
-#endif
+# endif
 
 		if (pollable->read_function || pollable->write_function)
 		{
@@ -164,13 +170,13 @@ static void mowgli_select_eventloop_select(mowgli_eventloop_t *eventloop, int de
 		{
 			pollable = n->data;
 
-			if ((FD_ISSET(pollable->fd, &rfds) || FD_ISSET(pollable->fd, &efds)) && pollable->read_function)
+			if ((FD_ISSET(pollable->fd, &rfds) || FD_ISSET(pollable->fd, &efds)))
 			{
-#ifdef DEBUG
+# ifdef DEBUG
 				mowgli_log("run %p(%p, %p, MOWGLI_EVENTLOOP_IO_READ, %p)\n", pollable->read_function, eventloop, pollable, pollable->userdata);
-#endif
+# endif
 
-				pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+				mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
 			}
 		}
 
@@ -178,19 +184,20 @@ static void mowgli_select_eventloop_select(mowgli_eventloop_t *eventloop, int de
 		{
 			pollable = n->data;
 
-			if ((FD_ISSET(pollable->fd, &wfds) || FD_ISSET(pollable->fd, &efds)) && pollable->write_function)
+			if ((FD_ISSET(pollable->fd, &wfds) || FD_ISSET(pollable->fd, &efds)))
 			{
-#ifdef DEBUG
+# ifdef DEBUG
 				mowgli_log("run %p(%p, %p, MOWGLI_EVENTLOOP_IO_WRITE, %p)\n", pollable->write_function, eventloop, pollable, pollable->userdata);
-#endif
+# endif
 
-				pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+				mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 			}
 		}
 	}
 }
 
-mowgli_eventloop_ops_t _mowgli_select_pollops = {
+mowgli_eventloop_ops_t _mowgli_select_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_select_eventloop_pollsetup,
diff --git a/src/libmowgli/eventloop/timer.c b/src/libmowgli/eventloop/timer.c
index d8c5061..efdbdea 100644
--- a/src/libmowgli/eventloop/timer.c
+++ b/src/libmowgli/eventloop/timer.c
@@ -23,8 +23,8 @@
 
 static mowgli_heap_t *timer_heap = NULL;
 
-static mowgli_eventloop_timer_t *mowgli_timer_add_real(mowgli_eventloop_t *eventloop,
-	const char *name, mowgli_event_dispatch_func_t *func, void *arg, time_t when, time_t frequency)
+static mowgli_eventloop_timer_t *
+mowgli_timer_add_real(mowgli_eventloop_t *eventloop, const char *name, mowgli_event_dispatch_func_t *func, void *arg, time_t when, time_t frequency)
 {
 	mowgli_eventloop_timer_t *timer;
 
@@ -39,36 +39,39 @@ static mowgli_eventloop_timer_t *mowgli_timer_add_real(mowgli_eventloop_t *event
 	timer->func = func;
 	timer->name = name;
 	timer->arg = arg;
-	timer->when = mowgli_eventloop_get_time(eventloop) + when;
+	timer->deadline = mowgli_eventloop_get_time(eventloop) + when;
 	timer->frequency = frequency;
 	timer->active = true;
 
-	if (eventloop->deadline <= mowgli_eventloop_get_time(eventloop) || timer->when <= eventloop->deadline)
-		eventloop->deadline = timer->when;
+	if (eventloop->deadline != -1 && timer->deadline <= eventloop->deadline)
+		eventloop->deadline = timer->deadline;
 
 	mowgli_node_add(timer, &timer->node, &eventloop->timer_list);
 
 #ifdef DEBUG
-	mowgli_log("[timer(%p) add when:%d active:%d] [eventloop deadline:%d]", timer, timer->when, timer->active, eventloop->deadline);
+	mowgli_log("[timer(%p) add when:%d active:%d] [eventloop deadline:%d]", timer, timer->deadline, timer->active, eventloop->deadline);
 #endif
 
 	return timer;
 }
 
 /* add an event to the table to be continually ran */
-mowgli_eventloop_timer_t *mowgli_timer_add(mowgli_eventloop_t *eventloop, const char *name, mowgli_event_dispatch_func_t *func, void *arg, time_t when)
+mowgli_eventloop_timer_t *
+mowgli_timer_add(mowgli_eventloop_t *eventloop, const char *name, mowgli_event_dispatch_func_t *func, void *arg, time_t when)
 {
 	return mowgli_timer_add_real(eventloop, name, func, arg, when, when);
 }
 
 /* adds an event to the table to be ran only once */
-mowgli_eventloop_timer_t *mowgli_timer_add_once(mowgli_eventloop_t *eventloop, const char *name, mowgli_event_dispatch_func_t *func, void *arg, time_t when)
+mowgli_eventloop_timer_t *
+mowgli_timer_add_once(mowgli_eventloop_t *eventloop, const char *name, mowgli_event_dispatch_func_t *func, void *arg, time_t when)
 {
 	return mowgli_timer_add_real(eventloop, name, func, arg, when, 0);
 }
 
 /* delete an event from the table */
-void mowgli_timer_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_timer_t *timer)
+void
+mowgli_timer_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_timer_t *timer)
 {
 	return_if_fail(eventloop != NULL);
 	return_if_fail(timer != NULL);
@@ -81,7 +84,8 @@ void mowgli_timer_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_timer_
 }
 
 /* checks all pending events */
-void mowgli_eventloop_run_timers(mowgli_eventloop_t *eventloop)
+void
+mowgli_eventloop_run_timers(mowgli_eventloop_t *eventloop)
 {
 	mowgli_node_t *n, *tn;
 	time_t currtime;
@@ -94,7 +98,7 @@ void mowgli_eventloop_run_timers(mowgli_eventloop_t *eventloop)
 	{
 		mowgli_eventloop_timer_t *timer = n->data;
 
-		if (timer->active && timer->when <= currtime)
+		if (timer->active && (timer->deadline <= currtime))
 		{
 			/* now we call it */
 			eventloop->last_ran = timer->name;
@@ -105,7 +109,9 @@ void mowgli_eventloop_run_timers(mowgli_eventloop_t *eventloop)
 
 			/* event is scheduled more than once */
 			if (timer->frequency)
-				timer->when = currtime + timer->frequency;
+			{
+				timer->deadline = currtime + timer->frequency;
+			}
 			else
 			{
 				/* XXX: yuck.  find a better way to handle this. */
@@ -118,36 +124,37 @@ void mowgli_eventloop_run_timers(mowgli_eventloop_t *eventloop)
 }
 
 /* returns the time the next mowgli_timer_run() should happen */
-time_t mowgli_eventloop_next_timer(mowgli_eventloop_t *eventloop)
+time_t
+mowgli_eventloop_next_timer(mowgli_eventloop_t *eventloop)
 {
 	mowgli_node_t *n;
 
 	return_val_if_fail(eventloop != NULL, 0);
 
 	if (eventloop->deadline == -1)
-	{
 		MOWGLI_ITER_FOREACH(n, eventloop->timer_list.head)
 		{
 			mowgli_eventloop_timer_t *timer = n->data;
 
-			if (timer->active && (timer->when < eventloop->deadline || eventloop->deadline == -1))
-				eventloop->deadline = timer->when;
+			if (timer->active && ((timer->deadline < eventloop->deadline) || (eventloop->deadline == -1)))
+				eventloop->deadline = timer->deadline;
 
 #ifdef DEBUG
-			mowgli_log("timer %p active:%d when:%ld deadline:%ld", timer, timer->active, timer->when, eventloop->deadline);
+			mowgli_log("timer %p active:%d when:%ld deadline:%ld", timer, timer->active, timer->deadline, eventloop->deadline);
 #endif
 		}
-	}
 
 #ifdef DEBUG
 	mowgli_log("eventloop deadline:%ld", eventloop->deadline);
+
 #endif
 
 	return eventloop->deadline;
 }
 
 /* finds an event in the table */
-mowgli_eventloop_timer_t *mowgli_timer_find(mowgli_eventloop_t *eventloop, mowgli_event_dispatch_func_t *func, void *arg)
+mowgli_eventloop_timer_t *
+mowgli_timer_find(mowgli_eventloop_t *eventloop, mowgli_event_dispatch_func_t *func, void *arg)
 {
 	mowgli_node_t *n;
 
@@ -158,7 +165,7 @@ mowgli_eventloop_timer_t *mowgli_timer_find(mowgli_eventloop_t *eventloop, mowgl
 	{
 		mowgli_eventloop_timer_t *timer = n->data;
 
-		if (timer->func == func && timer->arg == arg)
+		if ((timer->func == func) && (timer->arg == arg))
 			return timer;
 	}
 
diff --git a/src/libmowgli/eventloop/windows_pollops.c b/src/libmowgli/eventloop/windows_pollops.c
index f1c9c0f..8133bc1 100644
--- a/src/libmowgli/eventloop/windows_pollops.c
+++ b/src/libmowgli/eventloop/windows_pollops.c
@@ -22,9 +22,10 @@
 
 #ifdef _WIN32
 
-#define DEFAULT_SOCKETMAX	(2048)
+# define DEFAULT_SOCKETMAX (2048)
 
-typedef struct {
+typedef struct
+{
 	WSAEVENT *pfd;
 	unsigned short pfd_size;
 	unsigned short last_slot;
@@ -33,11 +34,13 @@ typedef struct {
 
 static WSADATA wsock_env;
 
-void mowgli_winsock_bootstrap(void)
+void
+mowgli_winsock_bootstrap(void)
 {
 	int r;
 
 	r = WSAStartup((short) 0x202, &wsock_env);
+
 	if (r != 0)
 	{
 		printf("mowgli bootstrap failure (win32): %d\n", r);
@@ -50,7 +53,8 @@ void mowgli_winsock_bootstrap(void)
 		wsock_env.iMaxSockets -= (wsock_env.iMaxSockets % MAXIMUM_WAIT_OBJECTS);
 }
 
-static void mowgli_winsock_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
+static void
+mowgli_winsock_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 {
 	unsigned short i;
 	mowgli_winsock_eventloop_private_t *priv;
@@ -74,7 +78,8 @@ static void mowgli_winsock_eventloop_pollsetup(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static unsigned short mowgli_winsock_eventloop_find_slot(mowgli_winsock_eventloop_private_t *priv)
+static unsigned short
+mowgli_winsock_eventloop_find_slot(mowgli_winsock_eventloop_private_t *priv)
 {
 	unsigned short i = 1;
 
@@ -84,23 +89,20 @@ static unsigned short mowgli_winsock_eventloop_find_slot(mowgli_winsock_eventloo
 		i = priv->last_slot;
 
 	for (; i < priv->pfd_size; i++)
-	{
 		if (priv->pfd[i] == INVALID_HANDLE_VALUE)
 		{
 			priv->last_slot = i;
 			return i;
 		}
-	}
 
 	/* miss, try from beginning. */
+
 	for (i = 1; i < priv->pfd_size; i++)
-	{
 		if (priv->pfd[i] == INVALID_HANDLE_VALUE)
 		{
 			priv->last_slot = i;
 			return i;
 		}
-	}
 
 	/* if this happens, we're boned... */
 	mowgli_log("out of handles for eventloop %p, aborting\n", priv);
@@ -109,7 +111,8 @@ static unsigned short mowgli_winsock_eventloop_find_slot(mowgli_winsock_eventloo
 	return 0;
 }
 
-static void mowgli_winsock_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
+static void
+mowgli_winsock_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 {
 	unsigned short i;
 	mowgli_winsock_eventloop_private_t *priv;
@@ -130,7 +133,8 @@ static void mowgli_winsock_eventloop_pollshutdown(mowgli_eventloop_t *eventloop)
 	return;
 }
 
-static void mowgli_winsock_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
+static void
+mowgli_winsock_eventloop_destroy(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable)
 {
 	mowgli_winsock_eventloop_private_t *priv;
 
@@ -152,7 +156,8 @@ static void mowgli_winsock_eventloop_destroy(mowgli_eventloop_t *eventloop, mowg
 	pollable->events = 0;
 }
 
-static void mowgli_winsock_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
+static void
+mowgli_winsock_eventloop_setselect(mowgli_eventloop_t *eventloop, mowgli_eventloop_pollable_t *pollable, mowgli_eventloop_io_dir_t dir, mowgli_eventloop_io_cb_t *event_function)
 {
 	mowgli_winsock_eventloop_private_t *priv;
 	unsigned int old_flags;
@@ -163,9 +168,9 @@ static void mowgli_winsock_eventloop_setselect(mowgli_eventloop_t *eventloop, mo
 	priv = eventloop->poller;
 	old_flags = pollable->events;
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("setselect %p fd %d func %p", pollable, pollable->fd, event_function);
-#endif
+# endif
 
 	switch (dir)
 	{
@@ -182,9 +187,9 @@ static void mowgli_winsock_eventloop_setselect(mowgli_eventloop_t *eventloop, mo
 		break;
 	}
 
-#ifdef DEBUG
+# ifdef DEBUG
 	mowgli_log("%p -> read %p : write %p", pollable, pollable->read_function, pollable->write_function);
-#endif
+# endif
 
 	if (pollable->read_function == NULL)
 		pollable->events &= ~(FD_READ | FD_CLOSE | FD_ACCEPT | FD_OOB);
@@ -192,8 +197,10 @@ static void mowgli_winsock_eventloop_setselect(mowgli_eventloop_t *eventloop, mo
 	if (pollable->write_function == NULL)
 		pollable->events &= ~(FD_WRITE | FD_CONNECT | FD_CLOSE);
 
-	if (old_flags == 0 && pollable->events == 0)
+	if ((old_flags == 0) && (pollable->events == 0))
+	{
 		return;
+	}
 	else if (pollable->events <= 0)
 	{
 		mowgli_winsock_eventloop_destroy(eventloop, pollable);
@@ -220,7 +227,8 @@ static void mowgli_winsock_eventloop_setselect(mowgli_eventloop_t *eventloop, mo
 	return;
 }
 
-static void mowgli_winsock_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
+static void
+mowgli_winsock_eventloop_select(mowgli_eventloop_t *eventloop, int delay)
 {
 	mowgli_winsock_eventloop_private_t *priv;
 	int i, j;
@@ -252,18 +260,19 @@ static void mowgli_winsock_eventloop_select(mowgli_eventloop_t *eventloop, int d
 
 			WSAEnumNetworkEvents(pollable->fd, priv->pfd[pollable->slot], &events);
 
-			if (events.lNetworkEvents & (FD_READ | FD_CLOSE | FD_ACCEPT | FD_OOB) && pollable->read_function != NULL)
-				pollable->read_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ, pollable->userdata);
+			if (events.lNetworkEvents & (FD_READ | FD_CLOSE | FD_ACCEPT | FD_OOB))
+				mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_READ);
 
-			if (events.lNetworkEvents & (FD_WRITE | FD_CONNECT | FD_CLOSE) && pollable->write_function != NULL)
-				pollable->write_function(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE, pollable->userdata);
+			if (events.lNetworkEvents & (FD_WRITE | FD_CONNECT | FD_CLOSE))
+				mowgli_pollable_trigger(eventloop, pollable, MOWGLI_EVENTLOOP_IO_WRITE);
 		}
 	}
 
 	mowgli_eventloop_synchronize(eventloop);
 }
 
-mowgli_eventloop_ops_t _mowgli_winsock_pollops = {
+mowgli_eventloop_ops_t _mowgli_winsock_pollops =
+{
 	.timeout_once = mowgli_simple_eventloop_timeout_once,
 	.run_once = mowgli_simple_eventloop_run_once,
 	.pollsetup = mowgli_winsock_eventloop_pollsetup,