--- a/src/event/modules/ngx_kqueue_module.c
+++ b/src/event/modules/ngx_kqueue_module.c
@@ -16,10 +16,16 @@
 #endif
 
 
+/* STUB */
+#define KQUEUE_NCHANGES  512
+#define KQUEUE_NEVENTS   512
+
+
 /* should be per-thread */
 static int              kq;
 static struct kevent   *change_list, *event_list;
-static int              nchanges, nevents;
+static unsigned int     nchanges;
+static int              nevents;
 
 static ngx_event_t      timer_queue;
 /* */
@@ -27,11 +33,12 @@ static ngx_event_t      timer_queue;
 
 int ngx_kqueue_init(int max_connections, ngx_log_t *log)
 {
-    int size;
+    int  change_size, event_size;
 
-    size = sizeof(struct kevent) * 512;
+    nevents = KQUEUE_NEVENTS;
     nchanges = 0;
-    nevents = 512;
+    change_size = sizeof(struct kevent) * KQUEUE_NCHANGES;
+    event_size = sizeof(struct kevent) * KQUEUE_NEVENTS;
 
     kq = kqueue();
 
@@ -40,8 +47,8 @@ int ngx_kqueue_init(int max_connections,
         return NGX_ERROR;
     }
 
-    ngx_test_null(change_list, ngx_alloc(size, log), NGX_ERROR);
-    ngx_test_null(event_list, ngx_alloc(size, log), NGX_ERROR);
+    ngx_test_null(change_list, ngx_alloc(change_size, log), NGX_ERROR);
+    ngx_test_null(event_list, ngx_alloc(event_size, log), NGX_ERROR);
 
     timer_queue.timer_prev = &timer_queue;
     timer_queue.timer_next = &timer_queue;
@@ -59,16 +66,17 @@ int ngx_kqueue_init(int max_connections,
 
 int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
 {
+    ev->active = 1;
     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
 
     if (nchanges > 0
         && ev->index < nchanges
         && change_list[ev->index].udata == ev)
     {
-        /* DEBUG */
+#if (NGX_DEBUG_EVENT)
         ngx_connection_t *c = (ngx_connection_t *) ev->data;
         ngx_log_debug(ev->log, "kqueue add event: %d: ft:%d" _ c->fd _ event);
-
+#endif
         change_list[ev->index].filter = event;
         change_list[ev->index].flags = flags;
 
@@ -81,16 +89,18 @@ int ngx_kqueue_add_event(ngx_event_t *ev
 
 int ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_event_t *e;
+    ngx_event_t  *e;
+
+    ev->active = 0;
 
     if (nchanges > 0
         && ev->index < nchanges
         && change_list[ev->index].udata == ev)
     {
-        /* DEBUG */
+#if (NGX_DEBUG_EVENT)
         ngx_connection_t *c = (ngx_connection_t *) ev->data;
         ngx_log_debug(ev->log, "kqueue del event: %d: ft:%d" _ c->fd _ event);
-
+#endif
         if (ev->index < --nchanges) {
             e = (ngx_event_t *) change_list[nchanges].udata;
             change_list[ev->index] = change_list[nchanges];
@@ -100,8 +110,9 @@ int ngx_kqueue_del_event(ngx_event_t *ev
         return NGX_OK;
     }
 
-    if (flags & NGX_CLOSE_EVENT)
+    if (flags & NGX_CLOSE_EVENT) {
         return NGX_OK;
+    }
 
     return ngx_kqueue_set_event(ev, event, EV_DELETE);
 }
@@ -109,15 +120,17 @@ int ngx_kqueue_del_event(ngx_event_t *ev
 
 int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
 {
-    struct timespec   ts;
-    ngx_connection_t *c;
+    struct timespec    ts;
+    ngx_connection_t  *c;
 
     c = (ngx_connection_t *) ev->data;
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(ev->log, "kqueue set event: %d: ft:%d f:%08x" _
                   c->fd _ filter _ flags);
+#endif
 
-    if (nchanges >= nevents) {
+    if (nchanges >= KQUEUE_NCHANGES) {
         ngx_log_error(NGX_LOG_WARN, ev->log, 0,
                       "kqueue change list is filled up");
 
@@ -128,6 +141,7 @@ int ngx_kqueue_set_event(ngx_event_t *ev
             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent failed");
             return NGX_ERROR;
         }
+
         nchanges = 0;
     }
 
@@ -168,7 +182,9 @@ int ngx_kqueue_process_events(ngx_log_t 
         tp = NULL;
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(log, "kevent timer: %d" _ timer);
+#endif
 
     events = kevent(kq, change_list, nchanges, event_list, nevents, tp);
 
@@ -184,38 +200,25 @@ int ngx_kqueue_process_events(ngx_log_t 
         delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
 
     } else {
-        ngx_assert((events != 0), return NGX_ERROR, log,
-                   "kevent returns no events without timeout");
-    }
-
-    ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
-
-    if (timer) {
-        if (delta >= timer) {
-            for ( ;; ) {
-                ev = timer_queue.timer_next;
-
-                if (ev == &timer_queue || delta < ev->timer_delta)
-                    break;
-
-                delta -= ev->timer_delta;
-                ngx_del_timer(ev);
-                ev->timedout = 1;
-                if (ev->event_handler(ev) == NGX_ERROR)
-                    ev->close_handler(ev);
-            }
-
-        } else {
-           timer_queue.timer_next->timer_delta -= delta;
+        if (events == 0) {
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "kevent returns no events without timeout");
+            return NGX_ERROR;
         }
     }
 
+#if (NGX_DEBUG_EVENT)
+    ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
+#endif
+
     for (i = 0; i < events; i++) {
 
+#if (NGX_DEBUG_EVENT)
         ngx_log_debug(log, "kevent: %d: ft:%d f:%08x ff:%08x d:%d ud:%08x" _
                       event_list[i].ident _ event_list[i].filter _
                       event_list[i].flags _ event_list[i].fflags _
                       event_list[i].data _ event_list[i].udata);
+#endif
 
         if (event_list[i].flags & EV_ERROR) {
             ngx_log_error(NGX_LOG_ALERT, log, event_list[i].data,
@@ -225,6 +228,10 @@ int ngx_kqueue_process_events(ngx_log_t 
 
         ev = (ngx_event_t *) event_list[i].udata;
 
+        if (!ev->active) {
+           continue;
+        }
+
         switch (event_list[i].filter) {
 
         case EVFILT_READ:
@@ -237,17 +244,42 @@ int ngx_kqueue_process_events(ngx_log_t 
                 ev->error = event_list[i].fflags;
             }
 
-            if (ev->oneshot)
+            if (ev->oneshot) {
                 ngx_del_timer(ev);
+            }
 
-            if (ev->event_handler(ev) == NGX_ERROR)
+            if (ev->event_handler(ev) == NGX_ERROR) {
                 ev->close_handler(ev);
+            }
 
             break;
 
         default:
-            ngx_assert(0, /* void */, log,
-                       "unknown kevent filter %d" _ event_list[i].filter);
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "unknown kevent filter %d" _ event_list[i].filter);
+        }
+    }
+
+    if (timer && timer_queue.timer_next != &timer_queue) {
+        if (delta >= timer_queue.timer_next->timer_delta) {
+            for ( ;; ) {
+                ev = timer_queue.timer_next;
+
+                if (ev == &timer_queue || delta < ev->timer_delta) {
+                    break;
+                }
+
+                delta -= ev->timer_delta;
+
+                ngx_del_timer(ev);
+                ev->timedout = 1;
+                if (ev->event_handler(ev) == NGX_ERROR) {
+                    ev->close_handler(ev);
+                }
+            }
+
+        } else {
+           timer_queue.timer_next->timer_delta -= delta;
         }
     }
 
@@ -257,19 +289,24 @@ int ngx_kqueue_process_events(ngx_log_t 
 
 void ngx_kqueue_add_timer(ngx_event_t *ev, ngx_msec_t timer)
 {
-    ngx_event_t *e;
+    ngx_event_t  *e;
 
-#if (NGX_DEBUG)
+#if (NGX_DEBUG_EVENT)
     ngx_connection_t *c = (ngx_connection_t *) ev->data;
     ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
 #endif
-    ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
-               "timer already set");
+
+    if (ev->timer_next || ev->timer_prev) {
+        ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
+        return;
+    }
 
     for (e = timer_queue.timer_next;
          e != &timer_queue && timer > e->timer_delta;
          e = e->timer_next)
+    {
         timer -= e->timer_delta;
+    }
 
     ev->timer_delta = timer;