diff --git a/src/core/nginx.c b/src/core/nginx.c
index cc13f75..e08ca16 100644
--- a/src/core/nginx.c
+++ b/src/core/nginx.c
@@ -29,19 +29,26 @@
 static ngx_command_t  ngx_core_commands[] = {
 
     { ngx_string("daemon"),
-      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
+      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
       ngx_conf_set_flag_slot,
       0,
       offsetof(ngx_core_conf_t, daemon),
       NULL },
 
     { ngx_string("master_process"),
-      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
+      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
       ngx_conf_set_flag_slot,
       0,
       offsetof(ngx_core_conf_t, master),
       NULL },
 
+    { ngx_string("timer_resolution"),
+      NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_msec_slot,
+      0,
+      offsetof(ngx_core_conf_t, timer_resolution),
+      NULL },
+
     { ngx_string("pid"),
       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
       ngx_conf_set_str_slot,
@@ -534,6 +541,8 @@
 
     ccf->daemon = NGX_CONF_UNSET;
     ccf->master = NGX_CONF_UNSET;
+    ccf->timer_resolution = NGX_CONF_UNSET_MSEC;
+
     ccf->worker_processes = NGX_CONF_UNSET;
     ccf->debug_points = NGX_CONF_UNSET;
 
@@ -564,6 +573,8 @@
 
     ngx_conf_init_value(ccf->daemon, 1);
     ngx_conf_init_value(ccf->master, 1);
+    ngx_conf_init_msec_value(ccf->timer_resolution, 0);
+
     ngx_conf_init_value(ccf->worker_processes, 1);
     ngx_conf_init_value(ccf->debug_points, 0);
 
diff --git a/src/core/nginx.h b/src/core/nginx.h
index 67e8e6b..e482c42 100644
--- a/src/core/nginx.h
+++ b/src/core/nginx.h
@@ -8,7 +8,7 @@
 #define _NGINX_H_INCLUDED_
 
 
-#define NGINX_VER          "nginx/0.3.2"
+#define NGINX_VER          "nginx/0.3.3"
 
 #define NGINX_VAR          "NGINX"
 #define NGX_OLDPID_EXT     ".oldbin"
diff --git a/src/core/ngx_conf_file.c b/src/core/ngx_conf_file.c
index 0e671ef..78e61f8 100644
--- a/src/core/ngx_conf_file.c
+++ b/src/core/ngx_conf_file.c
@@ -624,7 +624,7 @@
     value = cf->args->elts;
     file = value[1];
 
-    if (ngx_conf_full_name(cf->cycle, &file) == NGX_ERROR){
+    if (ngx_conf_full_name(cf->cycle, &file) == NGX_ERROR) {
         return NGX_CONF_ERROR;
     }
 
diff --git a/src/core/ngx_config.h b/src/core/ngx_config.h
index 7c5687e..3b51e96 100644
--- a/src/core/ngx_config.h
+++ b/src/core/ngx_config.h
@@ -104,6 +104,9 @@
 #define ngx_align(p)    (u_char *) (((uintptr_t) p + NGX_ALIGN) & ~NGX_ALIGN)
 
 
+#define ngx_abort       abort
+
+
 /* TODO: auto_conf: ngx_inline   inline __inline __inline__ */
 #ifndef ngx_inline
 #define ngx_inline   inline
diff --git a/src/core/ngx_connection.c b/src/core/ngx_connection.c
index 3f36d31..cac3944 100644
--- a/src/core/ngx_connection.c
+++ b/src/core/ngx_connection.c
@@ -66,13 +66,12 @@
     ngx_uint_t                 i;
     ngx_listening_t           *ls;
     struct sockaddr_in        *sin;
+    socklen_t                  olen;
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
     ngx_err_t                  err;
-    socklen_t                  aflen;
     struct accept_filter_arg   af;
 #endif
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
-    socklen_t                  tlen;
     int                        timeout;
 #endif
 
@@ -126,12 +125,38 @@
 
         ls[i].backlog = -1;
 
+        olen = sizeof(int);
+
+        if (getsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF, (void *) &ls[i].rcvbuf,
+                       &olen)
+            == -1)
+        {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
+                          "getsockopt(SO_RCVBUF) %V failed, ignored",
+                          &ls[i].addr_text);
+
+            ls[i].rcvbuf = -1;
+        }
+
+        olen = sizeof(int);
+
+        if (getsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF, (void *) &ls[i].sndbuf,
+                       &olen)
+            == -1)
+        {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
+                          "getsockopt(SO_SNDBUF) %V failed, ignored",
+                          &ls[i].addr_text);
+
+            ls[i].sndbuf = -1;
+        }
+
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
 
         ngx_memzero(&af, sizeof(struct accept_filter_arg));
-        aflen = sizeof(struct accept_filter_arg);
+        olen = sizeof(struct accept_filter_arg);
 
-        if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &aflen)
+        if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &olen)
             == -1)
         {
             err = ngx_errno;
@@ -146,7 +171,7 @@
             continue;
         }
 
-        if (aflen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
+        if (olen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
             continue;
         }
 
@@ -162,9 +187,9 @@
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
 
         timeout = 0;
-        tlen = sizeof(int);
+        olen = sizeof(int);
 
-        if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &tlen)
+        if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &olen)
             == -1)
         {
             ngx_log_error(NGX_LOG_NOTICE, cycle->log, ngx_errno,
@@ -188,7 +213,8 @@
 ngx_int_t
 ngx_open_listening_sockets(ngx_cycle_t *cycle)
 {
-    ngx_uint_t        tries, failed, reuseaddr, i;
+    int               reuseaddr;
+    ngx_uint_t        i, tries, failed;
     ngx_err_t         err;
     ngx_log_t        *log;
     ngx_socket_t      s;
@@ -201,9 +227,9 @@
 
     log = cycle->log;
 
-    /* TODO: tries configurable */
+    /* TODO: configurable try number */
 
-    for (tries = /* STUB */ 5; tries; tries--) {
+    for (tries = 5 ; tries; tries--) {
         failed = 0;
 
         /* for each listening socket */
@@ -236,25 +262,19 @@
                 return NGX_ERROR;
             }
 
-#if (NGX_WIN32)
-
-            /*
-             * Winsock assignes a socket number divisible by 4
-             * so to find a connection we divide a socket number by 4.
-             */
-
-            if (s % 4) {
-                ngx_log_error(NGX_LOG_EMERG, log, 0,
-                              ngx_socket_n " created socket %d", s);
-                return NGX_ERROR;
-            }
-#endif
-
             if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
-                           (const void *) &reuseaddr, sizeof(int)) == -1) {
+                           (const void *) &reuseaddr, sizeof(int))
+                == -1)
+            {
                 ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                               "setsockopt(SO_REUSEADDR) %V failed",
                               &ls[i].addr_text);
+
+                if (ngx_close_socket(s) == -1)
+                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
+                                  ngx_close_socket_n " %V failed",
+                                  &ls[i].addr_text);
+
                 return NGX_ERROR;
             }
 
@@ -265,56 +285,54 @@
                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                   ngx_nonblocking_n " %V failed",
                                   &ls[i].addr_text);
-                    return NGX_ERROR;
-                }
-            }
 
-#if 0
-            if (ls[i].nonblocking) {
-                if (ngx_nonblocking(s) == -1) {
-                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
-                                  ngx_nonblocking_n " %V failed",
-                                  &ls[i].addr_text);
+                    if (ngx_close_socket(s) == -1)
+                        ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
+                                      ngx_close_socket_n " %V failed",
+                                      &ls[i].addr_text);
+
                     return NGX_ERROR;
                 }
             }
-#endif
 
             if (bind(s, ls[i].sockaddr, ls[i].socklen) == -1) {
                 err = ngx_socket_errno;
+
+                if (err == NGX_EADDRINUSE && ngx_test_config) {
+                    continue;
+                }
+
                 ngx_log_error(NGX_LOG_EMERG, log, err,
                               "bind() to %V failed", &ls[i].addr_text);
 
-                if (err != NGX_EADDRINUSE)
-                    return NGX_ERROR;
-
                 if (ngx_close_socket(s) == -1)
                     ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
                                   ngx_close_socket_n " %V failed",
                                   &ls[i].addr_text);
 
+                if (err != NGX_EADDRINUSE) {
+                    return NGX_ERROR;
+                }
+
                 failed = 1;
+
                 continue;
             }
 
-            if (listen(s, ls[i].backlog) == -1) {
-                ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
-                              "listen() to %V failed", &ls[i].addr_text);
-                return NGX_ERROR;
-            }
-
-            /* TODO: deferred accept */
+            ls[i].listen = 1;
 
             ls[i].fd = s;
         }
 
-        if (!failed)
+        if (!failed) {
             break;
+        }
 
         /* TODO: delay configurable */
 
         ngx_log_error(NGX_LOG_NOTICE, log, 0,
                       "try again to bind() after 500ms");
+
         ngx_msleep(500);
     }
 
@@ -328,6 +346,143 @@
 
 
 void
+ngx_configure_listening_socket(ngx_cycle_t *cycle)
+{
+    ngx_uint_t                 i;
+    ngx_listening_t           *ls;
+
+#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
+    struct accept_filter_arg   af;
+#endif
+#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
+    int                        timeout;
+#endif
+
+    ls = cycle->listening.elts;
+    for (i = 0; i < cycle->listening.nelts; i++) {
+
+        if (ls[i].rcvbuf != -1) {
+            if (setsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF,
+                           (const void *) &ls[i].rcvbuf, sizeof(int))
+                == -1)
+            {
+                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
+                              "setsockopt(SO_RCVBUF) %V failed, ignored",
+                              &ls[i].addr_text);
+                return;
+            }
+        }
+
+        if (ls[i].sndbuf != -1) {
+            if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF,
+                           (const void *) &ls[i].sndbuf, sizeof(int))
+                == -1)
+            {
+                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
+                              "setsockopt(SO_SNDBUF) %V failed, ignored",
+                              &ls[i].addr_text);
+                return;
+            }
+        }
+
+        if (ls[i].listen) {
+            if (listen(ls[i].fd, ls[i].backlog) == -1) {
+                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
+                              "changing the listen() backlog to %d "
+                              "for %V failed, ignored",
+                              &ls[i].addr_text, ls[i].backlog);
+            }
+        }
+
+        /*
+         * setting deferred mode should be last operation on socket,
+         * because code may prematurely continue cycle on failure
+         */
+
+#if (NGX_HAVE_DEFERRED_ACCEPT)
+
+#ifdef SO_ACCEPTFILTER
+
+        if (ls->delete_deferred) {
+            if (setsockopt(ls->fd, SOL_SOCKET, SO_ACCEPTFILTER, NULL, 0) == -1)
+            {
+                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                              "setsockopt(SO_ACCEPTFILTER, NULL) "
+                              "for %V failed, ignored",
+                              &ls->addr_text);
+
+                if (ls->accept_filter) {
+                    ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
+                                  "could not change the accept filter "
+                                  "to \"%s\" for %V, ignored",
+                                  ls->accept_filter, &ls->addr_text);
+                }
+
+                continue;
+            }
+
+            ls->deferred_accept = 0;
+        }
+
+        if (ls->add_deferred) {
+            ngx_memzero(&af, sizeof(struct accept_filter_arg));
+            (void) ngx_cpystrn((u_char *) af.af_name,
+                               (u_char *) ls->accept_filter, 16);
+
+            if (setsockopt(ls->fd, SOL_SOCKET, SO_ACCEPTFILTER,
+                           &af, sizeof(struct accept_filter_arg))
+                == -1)
+            {
+                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                              "setsockopt(SO_ACCEPTFILTER, \"%s\") "
+                              " for %V failed, ignored",
+                              ls->accept_filter, &ls->addr_text);
+                continue;
+            }
+
+            ls->deferred_accept = 1;
+        }
+
+#endif
+
+#ifdef TCP_DEFER_ACCEPT
+
+        if (ls->add_deferred || ls->delete_deferred) {
+
+            if (ls->add_deferred) {
+                timeout = (int) (ls->post_accept_timeout / 1000);
+
+            } else {
+                timeout = 0;
+            }
+
+            if (setsockopt(ls->fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
+                           &timeout, sizeof(int))
+                == -1)
+            {
+                ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                              "setsockopt(TCP_DEFER_ACCEPT, %d) for %V failed, "
+                              "ignored",
+                              timeout, &ls->addr_text);
+
+                continue;
+            }
+        }
+
+        if (ls->add_deferred) { 
+            ls->deferred_accept = 1;
+        }
+
+#endif
+
+#endif /* NGX_HAVE_DEFERRED_ACCEPT */
+    }
+
+    return;
+}
+
+
+void
 ngx_close_listening_sockets(ngx_cycle_t *cycle)
 {
     ngx_uint_t         i;
@@ -361,6 +516,9 @@
 
         c->fd = (ngx_socket_t) -1;
 
+        ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0,
+                       "close listening %V #%d ", &ls[i].addr_text, ls[i].fd);
+
         if (ngx_close_socket(ls[i].fd) == -1) {
             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
                           ngx_close_socket_n " %V failed", &ls[i].addr_text);
@@ -495,28 +653,27 @@
      * before we clean the connection
      */
 
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_OK) {
+    ngx_mutex_lock(ngx_posted_events_mutex);
 
-        if (c->read->prev) {
-            ngx_delete_posted_event(c->read);
-        }
-
-        if (c->write->prev) {
-            ngx_delete_posted_event(c->write);
-        }
-
-        c->read->closed = 1;
-        c->write->closed = 1;
-
-        if (c->single_connection) {
-            ngx_unlock(&c->lock);
-            c->read->locked = 0;
-            c->write->locked = 0;
-        }
-
-        ngx_mutex_unlock(ngx_posted_events_mutex);
+    if (c->read->prev) {
+        ngx_delete_posted_event(c->read);
     }
 
+    if (c->write->prev) {
+        ngx_delete_posted_event(c->write);
+    }
+
+    c->read->closed = 1;
+    c->write->closed = 1;
+
+    if (c->single_connection) {
+        ngx_unlock(&c->lock);
+        c->read->locked = 0;
+        c->write->locked = 0;
+    }
+
+    ngx_mutex_unlock(ngx_posted_events_mutex);
+
 #else
 
     if (c->read->prev) {
diff --git a/src/core/ngx_connection.h b/src/core/ngx_connection.h
index ca5b053..c2b77e0 100644
--- a/src/core/ngx_connection.h
+++ b/src/core/ngx_connection.h
@@ -25,7 +25,10 @@
 
     int                 family;
     int                 type;
+
     int                 backlog;
+    int                 rcvbuf;
+    int                 sndbuf;
 
     /* handler of accepted connection */
     ngx_connection_handler_pt   handler;
@@ -51,7 +54,7 @@
     unsigned            bound:1;       /* already bound */
     unsigned            inherited:1;   /* inherited from previous process */
     unsigned            nonblocking_accept:1;
-    unsigned            change_backlog:1;
+    unsigned            listen:1;
     unsigned            nonblocking:1;
     unsigned            shared:1;    /* shared between threads or processes */
     unsigned            addr_ntop:1;
@@ -162,6 +165,7 @@
     in_addr_t addr, in_port_t port);
 ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle);
 ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle);
+void ngx_configure_listening_socket(ngx_cycle_t *cycle);
 void ngx_close_listening_sockets(ngx_cycle_t *cycle);
 void ngx_close_connection(ngx_connection_t *c);
 ngx_int_t ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text);
diff --git a/src/core/ngx_cycle.c b/src/core/ngx_cycle.c
index d8f95fa..58679ed 100644
--- a/src/core/ngx_cycle.c
+++ b/src/core/ngx_cycle.c
@@ -37,7 +37,8 @@
 #endif
 
 
-ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
+ngx_cycle_t *
+ngx_init_cycle(ngx_cycle_t *old_cycle)
 {
     void                      *rv;
     ngx_uint_t                 i, n, failed;
@@ -45,18 +46,11 @@
     ngx_conf_t                 conf;
     ngx_pool_t                *pool;
     ngx_cycle_t               *cycle, **old;
-    ngx_socket_t               fd;
     ngx_list_part_t           *part;
     ngx_open_file_t           *file;
     ngx_listening_t           *ls, *nls;
     ngx_core_conf_t           *ccf;
     ngx_core_module_t         *module;
-#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
-    struct accept_filter_arg   af;
-#endif
-#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
-    int                        timeout;
-#endif
 
     log = old_cycle->log;
 
@@ -315,39 +309,19 @@
                     if (ngx_cmp_sockaddr(nls[n].sockaddr, ls[i].sockaddr)
                         == NGX_OK)
                     {
-                        fd = ls[i].fd;
-#if (NGX_WIN32)
-                        /*
-                         * Winsock assignes a socket number divisible by 4 so
-                         * to find a connection we divide a socket number by 4.
-                         */
-
-                        fd /= 4;
-#endif
-                        if (fd >= (ngx_socket_t) cycle->connection_n) {
-                            ngx_log_error(NGX_LOG_EMERG, log, 0,
-                                        "%d connections is not enough to hold "
-                                        "an open listening socket on %V, "
-                                        "required at least %d connections",
-                                        cycle->connection_n,
-                                        &ls[i].addr_text, fd);
-                            failed = 1;
-                            break;
-                        }
-
                         nls[n].fd = ls[i].fd;
                         nls[n].previous = &ls[i];
                         ls[i].remain = 1;
 
                         if (ls[n].backlog != nls[i].backlog) {
-                            nls[n].change_backlog = 1;
+                            nls[n].listen = 1;
                         }
 
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
 
                         /*
                          * FreeBSD, except the most recent versions,
-                         * can not remove accept filter
+                         * could not remove accept filter
                          */
                         nls[n].deferred_accept = ls[i].deferred_accept;
 
@@ -404,93 +378,13 @@
             }
         }
 
-        if (!ngx_test_config && !failed) {
+        if (!failed) {
             if (ngx_open_listening_sockets(cycle) == NGX_ERROR) {
                 failed = 1;
             }
 
-            if (!failed) {
-                ls = cycle->listening.elts;
-                for (i = 0; i < cycle->listening.nelts; i++) {
-
-                    if (ls[i].change_backlog) {
-                        if (listen(ls[i].fd, ls[i].backlog) == -1) {
-                            ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
-                                          "changing the listen() backlog to %d "
-                                          "for %V failed, ignored",
-                                          &ls[i].addr_text, ls[i].backlog);
-                        }
-                    }
-
-#if (NGX_HAVE_DEFERRED_ACCEPT)
-
-#ifdef SO_ACCEPTFILTER
-                    if (ls[i].delete_deferred) {
-                        if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
-                                       NULL, 0) == -1)
-                        {
-                            ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
-                                        "setsockopt(SO_ACCEPTFILTER, NULL) "
-                                        "for %V failed, ignored",
-                                        &ls[i].addr_text);
-
-                            if (ls[i].accept_filter) {
-                                ngx_log_error(NGX_LOG_ALERT, log, 0,
-                                        "could not change the accept filter "
-                                        "to \"%s\" for %V, ignored",
-                                        ls[i].accept_filter, &ls[i].addr_text);
-                            }
-
-                            continue;
-                        }
-
-                        ls[i].deferred_accept = 0;
-                    }
-
-                    if (ls[i].add_deferred) {
-                        ngx_memzero(&af, sizeof(struct accept_filter_arg));
-                        (void) ngx_cpystrn((u_char *) af.af_name,
-                                           (u_char *) ls[i].accept_filter, 16);
-
-                        if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
-                                 &af, sizeof(struct accept_filter_arg)) == -1)
-                        {
-                            ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
-                                        "setsockopt(SO_ACCEPTFILTER, \"%s\") "
-                                        "for %V failed, ignored",
-                                        ls[i].accept_filter, &ls[i].addr_text);
-                            continue;
-                        }
-
-                        ls[i].deferred_accept = 1;
-                    }
-#endif
-
-#ifdef TCP_DEFER_ACCEPT
-                    if (ls[i].add_deferred || ls[i].delete_deferred) {
-                        timeout = 0;
-
-                        if (ls[i].add_deferred) {
-                            timeout = (int) (ls[i].post_accept_timeout / 1000);
-                        }
-
-                        if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
-                                       &timeout, sizeof(int)) == -1)
-                        {
-                            ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
-                                        "setsockopt(TCP_DEFER_ACCEPT, %d) "
-                                        "for %V failed, ignored",
-                                        timeout, &ls[i].addr_text);
-                            continue;
-                        }
-                    }
-
-                    if (ls[i].add_deferred) {
-                        ls[i].deferred_accept = 1;
-                    }
-#endif
-#endif
-                }
+            if (!ngx_test_config && !failed) {
+                ngx_configure_listening_socket(cycle);
             }
         }
     }
@@ -680,7 +574,8 @@
 }
 
 
-static ngx_int_t ngx_cmp_sockaddr(struct sockaddr *sa1, struct sockaddr *sa2)
+static ngx_int_t
+ngx_cmp_sockaddr(struct sockaddr *sa1, struct sockaddr *sa2)
 {
     struct sockaddr_in  *sin1, *sin2;
 
@@ -707,7 +602,8 @@
 
 #if !(NGX_WIN32)
 
-ngx_int_t ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle)
+ngx_int_t
+ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle)
 {
     ngx_uint_t        trunc;
     size_t            len;
@@ -776,7 +672,8 @@
 }
 
 
-void ngx_delete_pidfile(ngx_cycle_t *cycle)
+void
+ngx_delete_pidfile(ngx_cycle_t *cycle)
 {   
     u_char           *name;
     ngx_core_conf_t  *ccf;
@@ -798,7 +695,8 @@
 #endif
 
 
-void ngx_reopen_files(ngx_cycle_t *cycle, ngx_uid_t user)
+void
+ngx_reopen_files(ngx_cycle_t *cycle, ngx_uid_t user)
 {
     ngx_fd_t          fd;
     ngx_uint_t        i;
@@ -936,7 +834,8 @@
 }
 
 
-static void ngx_clean_old_cycles(ngx_event_t *ev)
+static void
+ngx_clean_old_cycles(ngx_event_t *ev)
 {
     ngx_uint_t     i, n, found, live;
     ngx_log_t     *log;
diff --git a/src/core/ngx_cycle.h b/src/core/ngx_cycle.h
index a94444a..b297994 100644
--- a/src/core/ngx_cycle.h
+++ b/src/core/ngx_cycle.h
@@ -54,6 +54,8 @@
      ngx_flag_t               daemon;
      ngx_flag_t               master;
 
+     ngx_msec_t               timer_resolution;
+
      ngx_int_t                worker_processes;
      ngx_int_t                debug_points;
 
diff --git a/src/core/ngx_file.c b/src/core/ngx_file.c
index 76e71c7..0c65760 100644
--- a/src/core/ngx_file.c
+++ b/src/core/ngx_file.c
@@ -40,8 +40,8 @@
 {
     ngx_err_t                 err;
     ngx_atomic_uint_t         n;
-    ngx_pool_cleanup_file_t  *cln;
-
+    ngx_pool_cleanup_t       *cln;
+    ngx_pool_cleanup_file_t  *clnf;
 
     file->name.len = path->name.len + 1 + path->len + NGX_ATOMIC_T_LEN;
 
@@ -66,6 +66,11 @@
 
         ngx_create_hashed_filename(file, path);
 
+        cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t));
+        if (cln == NULL) {
+            return NGX_ERROR;
+        }
+
 #if 1
         file->fd = ngx_open_tempfile(file->name.data, persistent);
 #else
@@ -76,19 +81,13 @@
                        "temp fd:%d", file->fd);
 
         if (file->fd != NGX_INVALID_FILE) {
-            cln = ngx_palloc(pool, sizeof(ngx_pool_cleanup_file_t));
-            if (cln == NULL) {
-                return NGX_ERROR; 
-            }
 
-            cln->fd = file->fd;
-            cln->name = file->name.data;
-            cln->log = pool->log;
+            cln->handler = ngx_pool_cleanup_file;
+            clnf = cln->data;
 
-            if (ngx_pool_cleanup_add(pool, ngx_pool_cleanup_file, cln) == NULL)
-            {
-                return NGX_ERROR;
-            }
+            clnf->fd = file->fd;
+            clnf->name = file->name.data;
+            clnf->log = pool->log;
 
             return NGX_OK;
         }
diff --git a/src/core/ngx_palloc.c b/src/core/ngx_palloc.c
index 9bb50f7..d1e7bbd 100644
--- a/src/core/ngx_palloc.c
+++ b/src/core/ngx_palloc.c
@@ -207,7 +207,7 @@
 
 
 ngx_pool_cleanup_t *
-ngx_pool_cleanup_add(ngx_pool_t *p, ngx_pool_cleanup_pt handler, void *data)
+ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
 {
     ngx_pool_cleanup_t  *c;
 
@@ -216,12 +216,23 @@
         return NULL;
     }
 
-    c->handler = handler;
-    c->data = data;
+    if (size) {
+        c->data = ngx_palloc(p, size);
+        if (c->data == NULL) {
+            return NULL;
+        }
+
+    } else {
+        c->data = NULL;
+    }
+
+    c->handler = NULL;
     c->next = p->cleanup;
 
     p->cleanup = c;
 
+    ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, p->log, 0, "add cleanup: %p", c);
+
     return c;
 }
 
@@ -231,6 +242,9 @@
 {
     ngx_pool_cleanup_file_t  *c = data;
 
+    ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, c->log, 0, "run cleanup: %p, fd:%d",
+                   c, c->fd);
+
     if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
                       ngx_close_file_n " \"%s\" failed", c->name);
diff --git a/src/core/ngx_palloc.h b/src/core/ngx_palloc.h
index 62a5718..b8b1692 100644
--- a/src/core/ngx_palloc.h
+++ b/src/core/ngx_palloc.h
@@ -71,8 +71,7 @@
 ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);
 
 
-ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p,
-    ngx_pool_cleanup_pt handler, void *data);
+ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size);
 void ngx_pool_cleanup_file(void *data);
 
 
diff --git a/src/core/ngx_parse.c b/src/core/ngx_parse.c
index dad9efc..f8e5f6c 100644
--- a/src/core/ngx_parse.c
+++ b/src/core/ngx_parse.c
@@ -8,11 +8,13 @@
 #include <ngx_core.h>
 
 
-ngx_int_t ngx_parse_size(ngx_str_t *line)
+ssize_t
+ngx_parse_size(ngx_str_t *line)
 {
     u_char     last;
     size_t     len;
-    ngx_int_t  scale, size;
+    ssize_t    size;
+    ngx_int_t  scale;
 
     len = line->len;
     last = line->data[len - 1];
@@ -34,7 +36,7 @@
         scale = 1;
     }
 
-    size = ngx_atoi(line->data, len);
+    size = ngx_atosz(line->data, len);
     if (size == NGX_ERROR) {
         return NGX_ERROR;
     }
@@ -45,7 +47,8 @@
 }
 
 
-ngx_int_t ngx_parse_time(ngx_str_t *line, ngx_int_t sec)
+ngx_int_t
+ngx_parse_time(ngx_str_t *line, ngx_int_t sec)
 {
     size_t      len;
     u_char     *start, last;
diff --git a/src/core/ngx_parse.h b/src/core/ngx_parse.h
index 44fff2e..464cefc 100644
--- a/src/core/ngx_parse.h
+++ b/src/core/ngx_parse.h
@@ -15,7 +15,7 @@
 #define NGX_PARSE_LARGE_TIME  -2
 
 
-ngx_int_t ngx_parse_size(ngx_str_t *line);
+ssize_t ngx_parse_size(ngx_str_t *line);
 ngx_int_t ngx_parse_time(ngx_str_t *line, ngx_int_t sec);
 
 
diff --git a/src/core/ngx_radix_tree.c b/src/core/ngx_radix_tree.c
index f82a5e5..957ec30 100644
--- a/src/core/ngx_radix_tree.c
+++ b/src/core/ngx_radix_tree.c
@@ -205,6 +205,7 @@
     for ( ;; ) {
         if (node->parent->right == node) {
             node->parent->right = NULL;
+
         } else {
             node->parent->left = NULL;
         }
@@ -214,11 +215,15 @@
 
         node = node->parent;
 
-        if (node->right
-            || node->left
-            || node->value != NGX_RADIX_NO_VALUE
-            || node->parent == NULL)
-        {
+        if (node->right || node->left) {
+            break;
+        }
+
+        if (node->value != NGX_RADIX_NO_VALUE) {
+            break;
+        }
+
+        if (node->parent == NULL) {
             break;
         }
     }
diff --git a/src/core/ngx_spinlock.c b/src/core/ngx_spinlock.c
index 00e7fca..a3082a0 100644
--- a/src/core/ngx_spinlock.c
+++ b/src/core/ngx_spinlock.c
@@ -12,7 +12,8 @@
  * TODO: the P4 optimized assembler version with the "pause" operation
  */
 
-void ngx_spinlock(ngx_atomic_t *lock, ngx_uint_t spin)
+void
+ngx_spinlock(ngx_atomic_t *lock, ngx_uint_t spin)
 {
 
 #if (NGX_HAVE_ATOMIC_OPS)
diff --git a/src/core/ngx_times.c b/src/core/ngx_times.c
index c806d55..88a9e98 100644
--- a/src/core/ngx_times.c
+++ b/src/core/ngx_times.c
@@ -8,61 +8,33 @@
 #include <ngx_core.h>
 
 
-ngx_msec_t        ngx_current_time;
-
-ngx_int_t         ngx_gmtoff;
-
-static ngx_tm_t   ngx_cached_gmtime;
-
-
 /*
- * In the threaded mode only one thread updates the cached time and strings
- * and these operations are protected by the mutex.  The reading of the cached
- * time and strings is not protected by the mutex.  To avoid the race
- * conditions for non-atomic values we use the NGX_TIME_SLOTS slots to store
- * time value and strings.  Thus thread may get the corrupted values only
- * if it is preempted while copying and then it is not scheduled to run
- * more than NGX_TIME_SLOTS seconds.
+ * The time may be updated by signal handler or by several threads.
+ * The time update operations are rare and require to hold the ngx_time_lock.
+ * The time read operations are frequent, so they are lock-free and get time
+ * values and strings from the current slot.  Thus thread may get the corrupted
+ * values only if it is preempted while copying and then it is not scheduled
+ * to run more than NGX_TIME_SLOTS seconds.
  */
 
-#if (NGX_THREADS)
+#define NGX_TIME_SLOTS   64
 
-#define NGX_TIME_SLOTS  60
-static ngx_uint_t       slot = NGX_TIME_SLOTS;
+static ngx_uint_t        slot = NGX_TIME_SLOTS;
+static ngx_atomic_t      ngx_time_lock;
 
-static ngx_mutex_t     *ngx_time_mutex;
+volatile ngx_msec_t      ngx_current_msec;
+volatile ngx_time_t     *ngx_cached_time;
+volatile ngx_str_t       ngx_cached_err_log_time;
+volatile ngx_str_t       ngx_cached_http_time;
+volatile ngx_str_t       ngx_cached_http_log_time;
 
-#else
-
-#define NGX_TIME_SLOTS  1
-#define slot            0
-
-#endif
-
-
-#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
-
-volatile time_t  *ngx_cached_time;
-static time_t     cached_time[NGX_TIME_SLOTS];
-
-#else
-
-volatile time_t   ngx_cached_time;
-
-#endif
-
-
-ngx_thread_volatile ngx_str_t  ngx_cached_err_log_time;
-ngx_thread_volatile ngx_str_t  ngx_cached_http_time;
-ngx_thread_volatile ngx_str_t  ngx_cached_http_log_time;
-
-
-static u_char  cached_err_log_time[NGX_TIME_SLOTS]
-                                  [sizeof("1970/09/28 12:00:00")];
-static u_char  cached_http_time[NGX_TIME_SLOTS]
-                                  [sizeof("Mon, 28 Sep 1970 06:00:00 GMT")];
-static u_char  cached_http_log_time[NGX_TIME_SLOTS]
-                                  [sizeof("28/Sep/1970:12:00:00 +0600")];
+static ngx_time_t        cached_time[NGX_TIME_SLOTS];
+static u_char            cached_err_log_time[NGX_TIME_SLOTS]
+                                    [sizeof("1970/09/28 12:00:00")];
+static u_char            cached_http_time[NGX_TIME_SLOTS]
+                                    [sizeof("Mon, 28 Sep 1970 06:00:00 GMT")];
+static u_char            cached_http_log_time[NGX_TIME_SLOTS]
+                                    [sizeof("28/Sep/1970:12:00:00 +0600")];
 
 
 static char  *week[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
@@ -72,63 +44,29 @@
 void
 ngx_time_init(void)
 {
-    struct timeval  tv;
-
-    ngx_memzero(&ngx_cached_gmtime, sizeof(ngx_tm_t));
-#ifdef ngx_tm_zone
-    ngx_cached_gmtime.ngx_tm_zone = "GMT";
-#endif
-
     ngx_cached_err_log_time.len = sizeof("1970/09/28 12:00:00") - 1;
     ngx_cached_http_time.len = sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1;
     ngx_cached_http_log_time.len = sizeof("28/Sep/1970:12:00:00 +0600") - 1;
 
-#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
     ngx_cached_time = &cached_time[0];
-#endif
-
-    ngx_gettimeofday(&tv);
-
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
 #if !(NGX_WIN32)
     tzset();
 #endif
 
-    ngx_time_update(tv.tv_sec);
+    ngx_time_update(0, 0);
 }
 
 
-#if (NGX_THREADS)
-
-ngx_int_t
-ngx_time_mutex_init(ngx_log_t *log)
-{
-    ngx_time_mutex = ngx_mutex_init(log, NGX_MUTEX_LIGHT);
-
-    if (ngx_time_mutex == NULL) {
-        return NGX_ERROR;
-    }
-
-    return NGX_OK;
-}
-
-#endif
-
-
 void
-ngx_time_update(time_t s)
+ngx_time_update(time_t sec, ngx_uint_t msec)
 {
-    u_char    *p;
-    ngx_tm_t   tm;
+    u_char          *p0, *p1, *p2;
+    ngx_tm_t         tm, gmt;
+    ngx_time_t      *tp;
+    struct timeval   tv;
 
-    if (ngx_time() == s) {
-        return;
-    }
-
-#if (NGX_THREADS)
-
-    if (ngx_mutex_trylock(ngx_time_mutex) != NGX_OK) {
+    if (!ngx_trylock(&ngx_time_lock)) {
         return;
     }
 
@@ -138,75 +76,80 @@
         slot++;
     }
 
-#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
-    ngx_cached_time = &cached_time[slot];
-#endif
+    if (sec == 0) {
+        ngx_gettimeofday(&tv);
 
-#endif
+        sec = tv.tv_sec;
+        msec = tv.tv_usec / 1000;
+    }
 
-    ngx_time() = s;
+    ngx_current_msec = (ngx_msec_t) sec * 1000 + msec;
 
-    ngx_gmtime(s, &ngx_cached_gmtime);
+    tp = &cached_time[slot];
+
+    tp->msec = msec;
+
+    if (tp->sec == sec) {
+        ngx_unlock(&ngx_time_lock);
+        return;
+    }
+
+    tp->sec = sec;
+
+    ngx_gmtime(sec, &gmt);
 
 
-    p = cached_http_time[slot];
+    p0 = cached_http_time[slot];
 
-    (void) ngx_sprintf(p, "%s, %02d %s %4d %02d:%02d:%02d GMT",
-                       week[ngx_cached_gmtime.ngx_tm_wday],
-                       ngx_cached_gmtime.ngx_tm_mday,
-                       months[ngx_cached_gmtime.ngx_tm_mon - 1],
-                       ngx_cached_gmtime.ngx_tm_year,
-                       ngx_cached_gmtime.ngx_tm_hour,
-                       ngx_cached_gmtime.ngx_tm_min,
-                       ngx_cached_gmtime.ngx_tm_sec);
-
-    ngx_cached_http_time.data = p;
-
+    (void) ngx_sprintf(p0, "%s, %02d %s %4d %02d:%02d:%02d GMT",
+                       week[gmt.ngx_tm_wday], gmt.ngx_tm_mday,
+                       months[gmt.ngx_tm_mon - 1], gmt.ngx_tm_year,
+                       gmt.ngx_tm_hour, gmt.ngx_tm_min, gmt.ngx_tm_sec);
 
 #if (NGX_HAVE_GETTIMEZONE)
 
-    ngx_gmtoff = ngx_gettimezone();
-    ngx_gmtime(s + ngx_gmtoff * 60, &tm);
+    tp->gmtoff = ngx_gettimezone();
+    ngx_gmtime(sec + tp->gmtoff * 60, &tm);
 
 #elif (NGX_HAVE_GMTOFF)
 
-    ngx_localtime(&tm);
-    ngx_gmtoff = (ngx_int_t) (tm.ngx_tm_gmtoff / 60);
+    ngx_localtime(sec, &tm);
+    tp->gmtoff = (ngx_int_t) (tm.ngx_tm_gmtoff / 60);
 
 #else
 
-    ngx_localtime(&tm);
-    ngx_gmtoff = ngx_timezone(tm.ngx_tm_isdst);
+    ngx_localtime(sec, &tm);
+    tp->gmtoff = ngx_timezone(tm.ngx_tm_isdst);
 
 #endif
 
 
-    p = cached_err_log_time[slot];
+    p1 = cached_err_log_time[slot];
 
-    (void) ngx_sprintf(p, "%4d/%02d/%02d %02d:%02d:%02d",
+    (void) ngx_sprintf(p1, "%4d/%02d/%02d %02d:%02d:%02d",
                        tm.ngx_tm_year, tm.ngx_tm_mon,
                        tm.ngx_tm_mday, tm.ngx_tm_hour,
                        tm.ngx_tm_min, tm.ngx_tm_sec);
 
-    ngx_cached_err_log_time.data = p;
 
+    p2 = cached_http_log_time[slot];
 
-    p = cached_http_log_time[slot];
-
-    (void) ngx_sprintf(p, "%02d/%s/%d:%02d:%02d:%02d %c%02d%02d",
+    (void) ngx_sprintf(p2, "%02d/%s/%d:%02d:%02d:%02d %c%02d%02d",
                        tm.ngx_tm_mday, months[tm.ngx_tm_mon - 1],
                        tm.ngx_tm_year, tm.ngx_tm_hour,
                        tm.ngx_tm_min, tm.ngx_tm_sec,
-                       ngx_gmtoff < 0 ? '-' : '+',
-                       abs(ngx_gmtoff / 60), abs(ngx_gmtoff % 60));
-
-    ngx_cached_http_log_time.data = p;
+                       tp->gmtoff < 0 ? '-' : '+',
+                       ngx_abs(tp->gmtoff / 60), ngx_abs(tp->gmtoff % 60));
 
 
-#if (NGX_THREADS)
-    ngx_mutex_unlock(ngx_time_mutex);
-#endif
+    ngx_memory_barrier();
 
+    ngx_cached_time = tp;
+    ngx_cached_http_time.data = p0;
+    ngx_cached_err_log_time.data = p1;
+    ngx_cached_http_log_time.data = p2;
+
+    ngx_unlock(&ngx_time_lock);
 }
 
 
diff --git a/src/core/ngx_times.h b/src/core/ngx_times.h
index bbcb413..6e7ab63 100644
--- a/src/core/ngx_times.h
+++ b/src/core/ngx_times.h
@@ -12,40 +12,34 @@
 #include <ngx_core.h>
 
 
+typedef struct {
+    time_t      sec;
+    ngx_uint_t  msec;
+    ngx_int_t   gmtoff;
+} ngx_time_t;
+
+
 void ngx_time_init(void);
-void ngx_time_update(time_t s);
+void ngx_time_update(time_t sec, ngx_uint_t msec);
 u_char *ngx_http_time(u_char *buf, time_t t);
 u_char *ngx_http_cookie_time(u_char *buf, time_t t);
 void ngx_gmtime(time_t t, ngx_tm_t *tp);
 
-#if (NGX_THREADS)
-ngx_int_t ngx_time_mutex_init(ngx_log_t *log);
-#endif
 
-#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
+extern volatile ngx_time_t  *ngx_cached_time;
 
-#define ngx_time()        *ngx_cached_time
-extern volatile time_t    *ngx_cached_time;
+#define ngx_time()           ngx_cached_time->sec
+#define ngx_timeofday()      (ngx_time_t *) ngx_cached_time
 
-#else
-
-#define ngx_time()         ngx_cached_time
-extern volatile time_t     ngx_cached_time;
-
-#endif
-
-
-extern ngx_thread_volatile ngx_str_t  ngx_cached_err_log_time;
-extern ngx_thread_volatile ngx_str_t  ngx_cached_http_time;
-extern ngx_thread_volatile ngx_str_t  ngx_cached_http_log_time;
-
-extern ngx_int_t   ngx_gmtoff;
+extern volatile ngx_str_t    ngx_cached_err_log_time;
+extern volatile ngx_str_t    ngx_cached_http_time;
+extern volatile ngx_str_t    ngx_cached_http_log_time;
 
 /*
  * milliseconds elapsed since epoch and truncated to ngx_msec_t,
  * used in event timers
  */
-extern ngx_msec_t  ngx_current_time;
+extern volatile ngx_msec_t  ngx_current_msec;
 
 
 #endif /* _NGX_TIMES_H_INCLUDED_ */
diff --git a/src/event/modules/ngx_aio_module.c b/src/event/modules/ngx_aio_module.c
index bf78a8e..fb3c8c8 100644
--- a/src/event/modules/ngx_aio_module.c
+++ b/src/event/modules/ngx_aio_module.c
@@ -14,12 +14,13 @@
 #endif
 
 
-static ngx_int_t ngx_aio_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_aio_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_aio_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_aio_add_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_aio_del_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_aio_del_connection(ngx_connection_t *c, u_int flags);
-static ngx_int_t ngx_aio_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_aio_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags);
 
 
 ngx_os_io_t ngx_os_aio = {
@@ -73,9 +74,9 @@
 #if (NGX_HAVE_KQUEUE)
 
 static ngx_int_t
-ngx_aio_init(ngx_cycle_t *cycle)
+ngx_aio_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
-    if (ngx_kqueue_module_ctx.actions.init(cycle) == NGX_ERROR) {
+    if (ngx_kqueue_module_ctx.actions.init(cycle, timer) == NGX_ERROR) {
         return NGX_ERROR;
     }
 
@@ -159,9 +160,9 @@
 
 
 static ngx_int_t
-ngx_aio_process_events(ngx_cycle_t *cycle)
+ngx_aio_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
 {
-    return ngx_kqueue_module_ctx.actions.process_events(cycle);
+    return ngx_kqueue_module_ctx.actions.process_events(cycle, timer, flags);
 }
 
 #endif /* NGX_HAVE_KQUEUE */
diff --git a/src/event/modules/ngx_devpoll_module.c b/src/event/modules/ngx_devpoll_module.c
index 7ee8602..54a5956 100644
--- a/src/event/modules/ngx_devpoll_module.c
+++ b/src/event/modules/ngx_devpoll_module.c
@@ -31,12 +31,13 @@
 } ngx_devpoll_conf_t;
 
 
-static ngx_int_t ngx_devpoll_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_devpoll_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags);
-static ngx_int_t ngx_devpoll_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_devpoll_process_events(ngx_cycle_t *cycle,
+    ngx_msec_t timer, ngx_uint_t flags);
 
 static void *ngx_devpoll_create_conf(ngx_cycle_t *cycle);
 static char *ngx_devpoll_init_conf(ngx_cycle_t *cycle, void *conf);
@@ -107,7 +108,7 @@
 
 
 static ngx_int_t
-ngx_devpoll_init(ngx_cycle_t *cycle)
+ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
     size_t               n;
     ngx_devpoll_conf_t  *dpcf;
@@ -323,48 +324,21 @@
 
 
 ngx_int_t
-ngx_devpoll_process_events(ngx_cycle_t *cycle)
+ngx_devpoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags)
 {
     int                 events, revents;
     size_t              n;
     ngx_err_t           err;
     ngx_int_t           i;
-    ngx_uint_t          lock, accept_lock;
-    ngx_msec_t          timer, delta;
-#if 0
-    ngx_cycle_t       **old_cycle;
-#endif
-    ngx_event_t        *rev, *wev;
+    ngx_uint_t          level;
+    ngx_msec_t          delta;
+    ngx_event_t        *rev, *wev, **queue;
     ngx_connection_t   *c;
     struct dvpoll       dvp;
-    struct timeval      tv;
-
-    timer = ngx_event_find_timer();
 
     /* NGX_TIMER_INFINITE == INFTIM */
 
-    accept_lock = 0;
-
-    if (ngx_accept_mutex) {
-        if (ngx_accept_disabled > 0) {
-            ngx_accept_disabled--;
-
-        } else {
-            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
-                return NGX_ERROR;
-            } 
-
-            if (ngx_accept_mutex_held) {
-                accept_lock = 1;
-
-            } else if (timer == NGX_TIMER_INFINITE
-                       || timer > ngx_accept_mutex_delay)
-            {
-                timer = ngx_accept_mutex_delay;
-            }
-        }
-    }
-
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "devpoll timer: %M", timer);
 
@@ -373,7 +347,6 @@
         if (write(dp, change_list, n) != (ssize_t) n) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                           "write(/dev/poll) failed");
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
     }
@@ -391,21 +364,32 @@
 
     nchanges = 0;
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
-
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    delta = ngx_current_msec;
+    
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
+    }
 
     if (err) {
-        ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
-                      cycle->log, err, "ioctl(DP_POLL) failed");
-        ngx_accept_mutex_unlock();
+        if (err == NGX_EINTR) {
+
+            if (ngx_event_timer_alarm) {
+                ngx_event_timer_alarm = 0;
+                return NGX_OK;
+            }
+ 
+            level = NGX_LOG_INFO;
+ 
+        } else { 
+            level = NGX_LOG_ALERT;
+        }
+
+        ngx_log_error(level, cycle->log, err, "ioctl(DP_POLL) failed");
         return NGX_ERROR;
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "devpoll timer: %M, delta: %M", timer, delta);
@@ -413,17 +397,15 @@
         if (events == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                           "ioctl(DP_POLL) returned no events without timeout");
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
     }
 
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        ngx_accept_mutex_unlock();
-        return NGX_ERROR;
+    if (events == 0) {
+        return NGX_OK;
     }
 
-    lock = 1;
+    ngx_mutex_lock(ngx_posted_events_mutex);
 
     for (i = 0; i < events; i++) {
         c = ngx_cycle->files[event_list[i].fd];
@@ -468,74 +450,49 @@
             revents |= POLLIN|POLLOUT;
         }
 
-        wev = c->write;
-
-        if ((revents & POLLOUT) && wev->active) {
-            wev->ready = 1;
-
-            if (!ngx_threaded && !ngx_accept_mutex_held) {
-                wev->handler(wev);
-
-            } else {
-                ngx_post_event(wev);
-            }
-        }
-
-        /*
-         * POLLIN must be handled after POLLOUT because we use
-         * the optimization to avoid the unnecessary mutex locking/unlocking
-         * if the accept event is the last one.
-         */
-
         rev = c->read;
 
         if ((revents & POLLIN) && rev->active) {
-            rev->ready = 1;
 
-            if (!ngx_threaded && !ngx_accept_mutex_held) {
+            if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
+                rev->posted_ready = 1;
+
+            } else {
+                rev->ready = 1;
+            }
+
+            if (flags & NGX_POST_EVENTS) {
+                queue = (ngx_event_t **) (rev->accept ?
+                               &ngx_posted_accept_events : &ngx_posted_events);
+
+                ngx_locked_post_event(rev, queue);
+
+            } else {
                 rev->handler(rev);
+            }
+        }
 
-            } else if (!rev->accept) {
-                ngx_post_event(rev);
+        wev = c->write;
 
-            } else if (ngx_accept_disabled <= 0) {
-                ngx_mutex_unlock(ngx_posted_events_mutex);
+        if ((revents & POLLOUT) && wev->active) {
 
-                c->read->handler(rev);
+            if (flags & NGX_POST_THREAD_EVENTS) {
+                wev->posted_ready = 1;
 
-                if (ngx_accept_disabled > 0) { 
-                    ngx_accept_mutex_unlock();
-                    accept_lock = 0;
-                }
+            } else {
+                wev->ready = 1;
+            }
 
-                if (i + 1 == events) {
-                    lock = 0;
-                    break;
-                }
+            if (flags & NGX_POST_EVENTS) {
+                ngx_locked_post_event(wev, &ngx_posted_events);
 
-                if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                    if (accept_lock) {
-                        ngx_accept_mutex_unlock();
-                    }
-                    return NGX_ERROR;
-                }
+            } else {
+                wev->handler(wev);
             }
         }
     }
 
-    if (accept_lock) {
-        ngx_accept_mutex_unlock();
-    }
-
-    if (lock) {
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-    }
-
-    ngx_event_expire_timers();
-
-    if (!ngx_threaded) {
-        ngx_event_process_posted(cycle);
-    }
+    ngx_mutex_unlock(ngx_posted_events_mutex);
 
     return NGX_OK;
 }
diff --git a/src/event/modules/ngx_epoll_module.c b/src/event/modules/ngx_epoll_module.c
index a53b8eb..14013dc 100644
--- a/src/event/modules/ngx_epoll_module.c
+++ b/src/event/modules/ngx_epoll_module.c
@@ -70,13 +70,14 @@
 } ngx_epoll_conf_t;
 
 
-static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_epoll_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_epoll_add_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_epoll_del_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_epoll_add_connection(ngx_connection_t *c);
 static ngx_int_t ngx_epoll_del_connection(ngx_connection_t *c, u_int flags);
-static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags);
 
 static void *ngx_epoll_create_conf(ngx_cycle_t *cycle);
 static char *ngx_epoll_init_conf(ngx_cycle_t *cycle, void *conf);
@@ -137,7 +138,7 @@
 
 
 static ngx_int_t
-ngx_epoll_init(ngx_cycle_t *cycle)
+ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
     ngx_event_conf_t  *ecf;
     ngx_epoll_conf_t  *epcf;
@@ -382,57 +383,20 @@
 
 
 static ngx_int_t
-ngx_epoll_process_events(ngx_cycle_t *cycle)
+ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
 {
     int                events;
     uint32_t           revents;
     ngx_int_t          instance, i;
-    ngx_uint_t         lock, accept_lock;
+    ngx_uint_t         level;
     ngx_err_t          err;
     ngx_log_t         *log;
-    ngx_msec_t         timer, delta;
-    ngx_event_t       *rev, *wev;
-    struct timeval     tv;
+    ngx_msec_t         delta;
+    ngx_event_t       *rev, *wev, **queue;
     ngx_connection_t  *c;
 
-    timer = ngx_event_find_timer();
-
-#if (NGX_THREADS)
-
-    if (timer == NGX_TIMER_ERROR) {
-        return NGX_ERROR;
-    }
-
-    if (timer == NGX_TIMER_INFINITE || timer > 500) {
-        timer = 500;
-    }
-
-#endif
-
     /* NGX_TIMER_INFINITE == INFTIM */
 
-    accept_lock = 0;
-
-    if (ngx_accept_mutex) {
-        if (ngx_accept_disabled > 0) {
-            ngx_accept_disabled--;
-
-        } else {
-            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            if (ngx_accept_mutex_held) {
-                accept_lock = 1;
-
-            } else if (timer == NGX_TIMER_INFINITE
-                       || timer > ngx_accept_mutex_delay)
-            {
-                timer = ngx_accept_mutex_delay;
-            }
-        }
-    }
-
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "epoll timer: %M", timer);
 
@@ -444,14 +408,14 @@
         err = 0;
     }
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
-
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    delta = ngx_current_msec;
+    
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
+    }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "epoll timer: %M, delta: %M", timer, delta);
@@ -459,30 +423,34 @@
         if (events == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                           "epoll_wait() returned no events without timeout");
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
     }
 
     if (err) {
-        ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
-                      cycle->log, err, "epoll_wait() failed");
-        ngx_accept_mutex_unlock();
+        if (err == NGX_EINTR) {
+
+            if (ngx_event_timer_alarm) {
+                ngx_event_timer_alarm = 0;
+                return NGX_OK;
+            }
+ 
+            level = NGX_LOG_INFO;
+ 
+        } else { 
+            level = NGX_LOG_ALERT;
+        }
+
+        ngx_log_error(level, cycle->log, err, "epoll_wait() failed");
         return NGX_ERROR;
     }
 
-    if (events > 0) {
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            ngx_accept_mutex_unlock();
-            return NGX_ERROR;
-        } 
-
-        lock = 1;
-
-    } else {
-        lock =0;
+    if (events == 0) {
+        return NGX_OK;
     }
 
+    ngx_mutex_lock(ngx_posted_events_mutex);
+
     log = cycle->log;
 
     for (i = 0; i < events; i++) {
@@ -539,94 +507,47 @@
             revents |= EPOLLIN|EPOLLOUT;
         }
 
+        if ((revents & EPOLLIN) && rev->active) {
+
+            if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
+                rev->posted_ready = 1;
+
+            } else {
+                rev->ready = 1;
+            }
+
+            if (flags & NGX_POST_EVENTS) {
+                queue = (ngx_event_t **) (rev->accept ?
+                               &ngx_posted_accept_events : &ngx_posted_events);
+
+                ngx_locked_post_event(rev, queue);
+
+            } else {
+                rev->handler(rev);
+            }
+        }
+
         wev = c->write;
 
         if ((revents & EPOLLOUT) && wev->active) {
 
-            if (ngx_threaded) {
+            if (flags & NGX_POST_THREAD_EVENTS) {
                 wev->posted_ready = 1;
-                ngx_post_event(wev);
 
             } else {
                 wev->ready = 1;
-
-                if (!ngx_accept_mutex_held) {
-                    wev->handler(wev);
-
-                } else {
-                    ngx_post_event(wev);
-                }
-            }
-        }
-
-        /*
-         * EPOLLIN must be handled after EPOLLOUT because we use
-         * the optimization to avoid the unnecessary mutex locking/unlocking
-         * if the accept event is the last one.
-         */
-
-        if ((revents & EPOLLIN) && rev->active) {
-
-            if (ngx_threaded && !rev->accept) {
-                rev->posted_ready = 1;
-
-                ngx_post_event(rev);
-
-                continue;
             }
 
-            rev->ready = 1;
+            if (flags & NGX_POST_EVENTS) {
+                ngx_locked_post_event(wev, &ngx_posted_events);
 
-            if (!ngx_threaded && !ngx_accept_mutex_held) {
-                rev->handler(rev);
-
-            } else if (!rev->accept) {
-                ngx_post_event(rev);
-
-            } else if (ngx_accept_disabled <= 0) {
-
-                ngx_mutex_unlock(ngx_posted_events_mutex);
-
-                rev->handler(rev);
-
-                if (ngx_accept_disabled > 0) {
-                    ngx_accept_mutex_unlock();
-                    accept_lock = 0;
-                }
-
-                if (i + 1 == events) {
-                    lock = 0;
-                    break;
-                }
-
-                if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                    if (accept_lock) {
-                        ngx_accept_mutex_unlock();
-                    }
-                    return NGX_ERROR;
-                }
+            } else {
+                wev->handler(wev);
             }
         }
     }
 
-    if (accept_lock) {
-        ngx_accept_mutex_unlock();
-    }
-
-    if (lock) {
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-    }
-
-    ngx_event_expire_timers();
-
-    if (ngx_posted_events) {
-        if (ngx_threaded) {
-            ngx_wakeup_worker_thread(cycle);
-
-        } else {
-            ngx_event_process_posted(cycle);
-        }
-    }
+    ngx_mutex_unlock(ngx_posted_events_mutex);
 
     return NGX_OK;
 }
diff --git a/src/event/modules/ngx_iocp_module.c b/src/event/modules/ngx_iocp_module.c
index 269d955..b7b1c62 100644
--- a/src/event/modules/ngx_iocp_module.c
+++ b/src/event/modules/ngx_iocp_module.c
@@ -10,11 +10,13 @@
 #include <ngx_iocp_module.h>
 
 
-static ngx_int_t ngx_iocp_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_iocp_init(ngx_cycle_t *cycle, ngx_msec_t timer);
+static ngx_thread_value_t __stdcall ngx_iocp_timer(void *data);
 static void ngx_iocp_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_iocp_add_event(ngx_event_t *ev, int event, u_int key);
 static ngx_int_t ngx_iocp_del_connection(ngx_connection_t *c, u_int flags);
-static ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags);
 static void *ngx_iocp_create_conf(ngx_cycle_t *cycle);
 static char *ngx_iocp_init_conf(ngx_cycle_t *cycle, void *conf);
 
@@ -93,11 +95,13 @@
 };
 
 
-static HANDLE  iocp;
+static HANDLE      iocp;
+static ngx_tid_t   timer_thread;
+static ngx_msec_t  msec;
 
 
 static ngx_int_t
-ngx_iocp_init(ngx_cycle_t *cycle)
+ngx_iocp_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
     ngx_iocp_conf_t  *cf;
 
@@ -109,7 +113,7 @@
     }
 
     if (iocp == NULL) {
-        ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
+        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                       "CreateIoCompletionPort() failed");
         return NGX_ERROR;
     }
@@ -120,10 +124,55 @@
 
     ngx_event_flags = NGX_USE_AIO_EVENT|NGX_USE_IOCP_EVENT;
 
+    if (timer == 0) {
+        return NGX_OK;
+    }
+
+    /*
+     * The waitable timer could not be used, because
+     * GetQueuedCompletionStatus() does not set a thread to alertable state
+     */
+
+    if (timer_thread == NULL) {
+
+        msec = timer;
+
+        if (ngx_create_thread(&timer_thread, ngx_iocp_timer, &msec, cycle->log)
+            != 0)
+        {
+            return NGX_ERROR;
+        }
+    }
+
+    ngx_event_flags |= NGX_USE_TIMER_EVENT;
+
     return NGX_OK;
 }
 
 
+static ngx_thread_value_t __stdcall
+ngx_iocp_timer(void *data)
+{
+    ngx_msec_t  timer = *(ngx_msec_t *) data;
+
+    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
+                   "THREAD %p %p", &msec, data);
+
+    for ( ;; ) {
+        Sleep(timer);
+
+        ngx_time_update(0, 0);
+#if 1
+        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer");
+#endif
+    }
+
+#ifdef __WATCOMC__
+    return 0;
+#endif
+}
+
+
 static void
 ngx_iocp_done(ngx_cycle_t *cycle)
 {
@@ -178,19 +227,17 @@
 
 
 static
-ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
+ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags)
 {
     int                rc;
     u_int              key;
     u_long             bytes;
     ngx_err_t          err;
-    ngx_msec_t         timer, delta;
+    ngx_msec_t         delta;
     ngx_event_t       *ev;
-    struct timeval     tv;
     ngx_event_ovlp_t  *ovlp;
 
-    timer = ngx_event_find_timer();
-
     if (timer == NGX_TIMER_INFINITE) {
         timer = INFINITE;
     }
@@ -206,17 +253,17 @@
         err = 0;
     }
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
+    delta = ngx_current_msec;
+    
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
+    }
 
     ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "iocp: %d b:%d k:%d ov:%p", rc, bytes, key, ovlp);
 
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
-
     if (timer != INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "iocp timer: %M, delta: %M", timer, delta);
@@ -231,8 +278,6 @@
                 return NGX_ERROR;
             }
 
-            ngx_event_expire_timers();
-
             return NGX_OK;
         }
 
@@ -263,8 +308,6 @@
         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
                        "iocp: aborted event %p", ev); 
 
-        ngx_event_expire_timers();
-
         return NGX_OK;
     }
 
@@ -297,8 +340,6 @@
 
     ev->handler(ev);
 
-    ngx_event_expire_timers();
-
     return NGX_OK;
 }
 
diff --git a/src/event/modules/ngx_kqueue_module.c b/src/event/modules/ngx_kqueue_module.c
index e80e1ab..1c6ab55 100644
--- a/src/event/modules/ngx_kqueue_module.c
+++ b/src/event/modules/ngx_kqueue_module.c
@@ -16,13 +16,14 @@
 } ngx_kqueue_conf_t;
 
 
-static ngx_int_t ngx_kqueue_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_kqueue_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags);
 static ngx_int_t ngx_kqueue_process_changes(ngx_cycle_t *cycle, ngx_uint_t try);
-static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags);
 static ngx_inline void ngx_kqueue_dump_event(ngx_log_t *log,
     struct kevent *kev);
 
@@ -111,8 +112,9 @@
 
 
 static ngx_int_t
-ngx_kqueue_init(ngx_cycle_t *cycle)
+ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
+    struct kevent       kev;
     struct timespec     ts;
     ngx_kqueue_conf_t  *kcf;
 
@@ -191,25 +193,50 @@
         }
     }
 
+    ngx_event_flags = 0;
+
+#if (NGX_HAVE_TIMER_EVENT)
+
+    if (timer) {
+        kev.ident = 0;
+        kev.filter = EVFILT_TIMER;
+        kev.flags = EV_ADD|EV_ENABLE;
+        kev.fflags = 0;
+        kev.data = timer;
+        kev.udata = 0;
+
+        ts.tv_sec = 0;
+        ts.tv_nsec = 0;
+
+        if (kevent(ngx_kqueue, &kev, 1, NULL, 0, &ts) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                          "kevent(EVFILT_TIMER) failed");
+            return NGX_ERROR;
+        }
+
+        ngx_event_flags |= NGX_USE_TIMER_EVENT;
+    }
+
+#endif
+
+    ngx_event_flags |= NGX_USE_ONESHOT_EVENT|NGX_USE_KQUEUE_EVENT;
+
+#if (NGX_HAVE_CLEAR_EVENT)
+    ngx_event_flags |= NGX_USE_CLEAR_EVENT;
+#else
+    ngx_event_flags |= NGX_USE_LEVEL_EVENT;
+#endif
+
+#if (NGX_HAVE_LOWAT_EVENT)
+    ngx_event_flags |= NGX_USE_LOWAT_EVENT;
+#endif
+
     nevents = kcf->events;
 
     ngx_io = ngx_os_io;
 
     ngx_event_actions = ngx_kqueue_module_ctx.actions;
 
-    ngx_event_flags = NGX_USE_ONESHOT_EVENT
-#if 1
-#if (NGX_HAVE_CLEAR_EVENT)
-                     |NGX_USE_CLEAR_EVENT
-#else
-                     |NGX_USE_LEVEL_EVENT
-#endif
-#endif
-#if (NGX_HAVE_LOWAT_EVENT)
-                     |NGX_USE_LOWAT_EVENT
-#endif
-                     |NGX_USE_KQUEUE_EVENT;
-
     return NGX_OK;
 }
 
@@ -254,9 +281,7 @@
     ev->disabled = 0;
     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
 
-    if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(list_mutex);
 
 #if 1
 
@@ -317,9 +342,7 @@
     ev->active = 0;
     ev->disabled = 0;
 
-    if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(list_mutex);
 
 #if 1
 
@@ -441,56 +464,19 @@
 
 
 static ngx_int_t
-ngx_kqueue_process_events(ngx_cycle_t *cycle)
+ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags)
 {
-    int                events, n;
-    ngx_int_t          i, instance;
-    ngx_uint_t         lock, accept_lock;
-    ngx_err_t          err;
-    ngx_msec_t         timer, delta;
-    ngx_event_t       *ev;
-    struct timeval     tv;
-    struct timespec    ts, *tp;
-
-    timer = ngx_event_find_timer();
-
-#if (NGX_THREADS)
-
-    if (timer == NGX_TIMER_ERROR) {
-        return NGX_ERROR;
-    }
-
-    if (timer == NGX_TIMER_INFINITE || timer > 500) {
-        timer = 500;
-    }
-
-#endif
-
-    accept_lock = 0;
-
-    if (ngx_accept_mutex) {
-        if (ngx_accept_disabled > 0) {
-            ngx_accept_disabled--;
-
-        } else {
-            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            if (ngx_accept_mutex_held) {
-                accept_lock = 1;
-
-            } else if (timer == NGX_TIMER_INFINITE
-                       || timer > ngx_accept_mutex_delay)
-            {
-                timer = ngx_accept_mutex_delay;
-            }
-        }
-    }
+    int               events, n;
+    ngx_int_t         i, instance;
+    ngx_uint_t        level;
+    ngx_err_t         err;
+    ngx_msec_t        delta;
+    ngx_event_t      *ev, **queue;
+    struct timespec   ts, *tp;
 
     if (ngx_threaded) {
         if (ngx_kqueue_process_changes(cycle, 0) == NGX_ERROR) {
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
 
@@ -521,24 +507,35 @@
         err = 0;
     }
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
+    delta = ngx_current_msec;
+
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
+    }
 
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "kevent events: %d", events);
 
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
-
     if (err) {
-        ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
-                      cycle->log, err, "kevent() failed");
-        ngx_accept_mutex_unlock();
+        if (err == NGX_EINTR) {
+
+            if (ngx_event_timer_alarm) {
+                ngx_event_timer_alarm = 0;
+                return NGX_OK;
+            }
+
+            level = NGX_LOG_INFO;
+
+        } else {
+            level = NGX_LOG_ALERT;
+        }
+
+        ngx_log_error(level, cycle->log, err, "kevent() failed");
         return NGX_ERROR;
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "kevent timer: %M, delta: %M", timer, delta);
@@ -547,23 +544,16 @@
         if (events == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                           "kevent() returned no events without timeout");
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
     }
 
-    if (events > 0) {
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            ngx_accept_mutex_unlock();
-            return NGX_ERROR;
-        }
-
-        lock = 1;
-
-    } else {
-        lock =0;
+    if (events == 0) {
+        return NGX_OK;
     }
 
+    ngx_mutex_lock(ngx_posted_events_mutex);
+
     for (i = 0; i < events; i++) {
 
         ngx_kqueue_dump_event(cycle->log, &event_list[i]);
@@ -574,6 +564,15 @@
             continue;
         }
 
+#if (NGX_HAVE_TIMER_EVENT)
+
+        if (event_list[i].filter == EVFILT_TIMER) {
+            ngx_time_update(0, 0);
+            continue;
+        }
+
+#endif
+
         ev = (ngx_event_t *) event_list[i].udata;
 
         switch (event_list[i].filter) {
@@ -606,7 +605,7 @@
 
 #if (NGX_THREADS)
 
-            if (ngx_threaded && !ev->accept) {
+            if ((flags & NGX_POST_THREAD_EVENTS) && !ev->accept) {
                 ev->posted_ready = 1;
                 ev->posted_available = event_list[i].data;
 
@@ -615,7 +614,7 @@
                     ev->posted_errno = event_list[i].fflags;
                 }
 
-                ngx_post_event(ev);
+                ngx_locked_post_event(ev, &ngx_posted_events);
 
                 continue;
             }
@@ -651,60 +650,18 @@
             continue;
         }
 
-        if (!ngx_threaded && !ngx_accept_mutex_held) {
-            ev->handler(ev);
+        if (flags & NGX_POST_EVENTS) {
+            queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
+                                                   &ngx_posted_events);
+            ngx_locked_post_event(ev, queue);
+
             continue;
         }
 
-        if (!ev->accept) {
-            ngx_post_event(ev);
-            continue;
-        }
-
-        if (ngx_accept_disabled > 0) {
-            continue;
-        }
-
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-
         ev->handler(ev);
-
-        if (ngx_accept_disabled > 0) {
-            ngx_accept_mutex_unlock();
-            accept_lock = 0;
-        }
-
-        if (i + 1 == events) {
-            lock = 0;
-            break;
-        }
-
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            if (accept_lock) {
-                ngx_accept_mutex_unlock();
-            }
-            return NGX_ERROR;
-        }
     }
 
-    if (accept_lock) {
-        ngx_accept_mutex_unlock();
-    }
-
-    if (lock) {
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-    }
-
-    ngx_event_expire_timers();
-
-    if (ngx_posted_events) {
-        if (ngx_threaded) {
-            ngx_wakeup_worker_thread(cycle);
-
-        } else {
-            ngx_event_process_posted(cycle);
-        }
-    }
+    ngx_mutex_unlock(ngx_posted_events_mutex);
 
     return NGX_OK;
 }
@@ -719,14 +676,9 @@
     struct timespec   ts;
     struct kevent    *changes;
 
-    if (ngx_mutex_lock(kevent_mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(kevent_mutex);
 
-    if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
-        ngx_mutex_unlock(kevent_mutex);
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(list_mutex);
 
     if (nchanges == 0) {
         ngx_mutex_unlock(list_mutex);
diff --git a/src/event/modules/ngx_poll_module.c b/src/event/modules/ngx_poll_module.c
index 29b375a..61d6179 100644
--- a/src/event/modules/ngx_poll_module.c
+++ b/src/event/modules/ngx_poll_module.c
@@ -9,23 +9,18 @@
 #include <ngx_event.h>
 
 
-static ngx_int_t ngx_poll_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_poll_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_poll_add_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags);
-static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags);
 static char *ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf);
 
 
 static struct pollfd  *event_list;
 static int             nevents;
 
-#if 0
-static ngx_event_t   **ready_index;
-#endif
-
-static ngx_event_t    *accept_events;
-
 
 static ngx_str_t    poll_name = ngx_string("poll");
 
@@ -67,7 +62,7 @@
 
 
 static ngx_int_t
-ngx_poll_init(ngx_cycle_t *cycle)
+ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
     struct pollfd   *list;
 
@@ -91,27 +86,13 @@
         }
 
         event_list = list;
-
-#if 0
-        if (ready_index) {
-            ngx_free(ready_index);
-        }
-
-        ready_index = ngx_alloc(sizeof(ngx_event_t *) * 2 * cycle->connection_n,
-                                cycle->log);
-        if (ready_index == NULL) {
-            return NGX_ERROR;
-        }
-#endif
     }
 
     ngx_io = ngx_os_io;
 
     ngx_event_actions = ngx_poll_module_ctx.actions;
 
-    ngx_event_flags = NGX_USE_LEVEL_EVENT
-                      |NGX_USE_ONESHOT_EVENT
-                      |NGX_USE_FD_EVENT;
+    ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_FD_EVENT;
 
     return NGX_OK;
 }
@@ -121,14 +102,8 @@
 ngx_poll_done(ngx_cycle_t *cycle)
 {
     ngx_free(event_list);
-#if 0
-    ngx_free(ready_index);
-#endif
 
     event_list = NULL;
-#if 0
-    ready_index = NULL;
-#endif
 }
 
 
@@ -189,10 +164,8 @@
 static ngx_int_t
 ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_uint_t          i;
-    ngx_cycle_t       **cycle;
-    ngx_event_t        *e;
-    ngx_connection_t   *c;
+    ngx_event_t       *e;
+    ngx_connection_t  *c;
 
     c = ev->data;
 
@@ -234,19 +207,6 @@
             c = ngx_cycle->files[event_list[nevents].fd];
 
             if (c->fd == -1) {
-                cycle = ngx_old_cycles.elts;
-                for (i = 0; i < ngx_old_cycles.nelts; i++) {
-                    if (cycle[i] == NULL) {
-                        continue;
-                    }
-                    c = cycle[i]->files[event_list[nevents].fd];
-                    if (c->fd != -1) {
-                        break;
-                    }
-                }
-            }
-
-            if (c->fd == -1) {
                 ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
                               "unexpected last event");
 
@@ -275,19 +235,15 @@
 
 
 static ngx_int_t
-ngx_poll_process_events(ngx_cycle_t *cycle)
+ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
 {
     int                 ready, revents;
     ngx_err_t           err;
     ngx_int_t           i, nready;
-    ngx_uint_t          n, found, lock;
-    ngx_msec_t          timer, delta;
-    ngx_cycle_t       **old_cycle;
-    ngx_event_t        *ev;
+    ngx_uint_t          found, level;
+    ngx_msec_t          delta;
+    ngx_event_t        *ev, **queue;
     ngx_connection_t   *c;
-    struct timeval      tv;
-
-    timer = ngx_event_find_timer();
 
     /* NGX_TIMER_INFINITE == INFTIM */
 
@@ -301,24 +257,6 @@
     }
 #endif
 
-    if (ngx_accept_mutex) {
-        if (ngx_accept_disabled > 0) {
-            ngx_accept_disabled--;
-
-        } else {
-            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            if (ngx_accept_mutex_held == 0
-                && (timer == NGX_TIMER_INFINITE
-                    || timer > ngx_accept_mutex_delay))
-            { 
-                timer = ngx_accept_mutex_delay;
-            } 
-        }
-    }
-
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);
 
     ready = poll(event_list, (u_int) nevents, (int) timer);
@@ -329,24 +267,35 @@
         err = 0;
     }
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
+    delta = ngx_current_msec;
 
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
+    }
 
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "poll ready %d of %d", ready, nevents);
 
     if (err) {
-        ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
-                      cycle->log, err, "poll() failed");
-        ngx_accept_mutex_unlock();
+        if (err == NGX_EINTR) {
+
+            if (ngx_event_timer_alarm) {
+                ngx_event_timer_alarm = 0;
+                return NGX_OK;
+            }
+ 
+            level = NGX_LOG_INFO;
+ 
+        } else { 
+            level = NGX_LOG_ALERT;
+        }
+
+        ngx_log_error(level, cycle->log, err, "poll() failed");
         return NGX_ERROR;
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "poll timer: %M, delta: %M", timer, delta);
@@ -354,24 +303,23 @@
         if (ready == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                           "poll() returned no events without timeout");
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
     }
 
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        ngx_accept_mutex_unlock();
-        return NGX_ERROR;
+    if (ready == 0) {
+        return NGX_OK;
     }
 
-    lock = 1;
+    ngx_mutex_lock(ngx_posted_events_mutex);
+
     nready = 0;
 
     for (i = 0; i < nevents && ready; i++) {
 
         revents = event_list[i].revents;
 
-#if 0
+#if 1
         ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "poll: %d: fd:%d ev:%04Xd rev:%04Xd",
                        i, event_list[i].fd, event_list[i].events, revents);
@@ -406,19 +354,6 @@
         c = ngx_cycle->files[event_list[i].fd];
 
         if (c->fd == -1) {
-            old_cycle = ngx_old_cycles.elts;
-            for (n = 0; n < ngx_old_cycles.nelts; n++) {
-                if (old_cycle[n] == NULL) {
-                    continue;
-                }
-                c = old_cycle[n]->files[event_list[i].fd];
-                if (c->fd != -1) {
-                    break;
-                }
-            }
-        }
-
-        if (c->fd == -1) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unexpected event");
 
             /*
@@ -453,43 +388,31 @@
             found = 1;
 
             ev = c->read;
-            ev->ready = 1;
 
-            if (ev->oneshot) {
-                if (ev->timer_set) {
-                    ngx_del_timer(ev);
-                }
-                ngx_poll_del_event(ev, NGX_READ_EVENT, 0);
-            }
+            if ((flags & NGX_POST_THREAD_EVENTS) && !ev->accept) {
+                ev->posted_ready = 1;
 
-            if (ev->accept) {
-                ev->next = accept_events;
-                accept_events = ev;
             } else {
-                ngx_post_event(ev);
+                ev->ready = 1;
             }
 
-#if 0
-            ready_index[nready++] = c->read;
-#endif
+            queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
+                                                   &ngx_posted_events);
+            ngx_locked_post_event(ev, queue); 
         }
 
         if (revents & POLLOUT) {
             found = 1;
             ev = c->write;
-            ev->ready = 1;
 
-            if (ev->oneshot) {
-                if (ev->timer_set) {
-                    ngx_del_timer(ev);
-                }
-                ngx_poll_del_event(ev, NGX_WRITE_EVENT, 0);
+            if (flags & NGX_POST_THREAD_EVENTS) {
+                ev->posted_ready = 1;
+
+            } else {
+                ev->ready = 1;
             }
 
-            ngx_post_event(ev);
-#if 0
-            ready_index[nready++] = c->write;
-#endif
+            ngx_locked_post_event(ev, &ngx_posted_events);
         }
 
         if (found) {
@@ -498,83 +421,12 @@
         }
     }
 
-#if 0
-    for (i = 0; i < nready; i++) {
-        ev = ready_index[i];
-
-        if (!ev->active) {
-            continue;
-        }
-
-        ev->ready = 1;
-
-        if (ev->oneshot) {
-            if (ev->timer_set) {
-                ngx_del_timer(ev);
-            }
-
-            if (ev->write) {
-                ngx_poll_del_event(ev, NGX_WRITE_EVENT, 0);
-            } else {
-                ngx_poll_del_event(ev, NGX_READ_EVENT, 0);
-            }
-        }
-
-        ev->handler(ev);
-    }
-#endif
-
-    ev = accept_events;
-
-    for ( ;; ) {
-
-        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                      "accept event %p", ev);
-
-        if (ev == NULL) {
-            break;
-        }
-
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-
-        ev->handler(ev);
-
-        if (ngx_accept_disabled > 0) {
-            lock = 0;
-            break;
-        }
-
-        ev = ev->next;
-
-        if (ev == NULL) {
-            lock = 0;
-            break;
-        }
-
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            ngx_accept_mutex_unlock();
-            return NGX_ERROR;
-        }
-
-    }
-
-    ngx_accept_mutex_unlock();
-    accept_events = NULL;
-
-    if (lock) {
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-    }
+    ngx_mutex_unlock(ngx_posted_events_mutex);
 
     if (ready != 0) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
     }
 
-    ngx_event_expire_timers();
-
-    if (!ngx_threaded) {
-        ngx_event_process_posted(cycle);
-    }
-
     return nready;
 }
 
diff --git a/src/event/modules/ngx_rtsig_module.c b/src/event/modules/ngx_rtsig_module.c
index f88dd5d..450943c 100644
--- a/src/event/modules/ngx_rtsig_module.c
+++ b/src/event/modules/ngx_rtsig_module.c
@@ -38,12 +38,14 @@
 
 extern ngx_event_module_t  ngx_poll_module_ctx;
 
-static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_rtsig_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_rtsig_add_connection(ngx_connection_t *c);
 static ngx_int_t ngx_rtsig_del_connection(ngx_connection_t *c, u_int flags);
-static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle);
-static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle);
+static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle,
+    ngx_msec_t timer, ngx_uint_t flags);
+static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle,
+    ngx_msec_t timer, ngx_uint_t flags);
 
 static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle);
 static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf);
@@ -134,7 +136,7 @@
 
 
 static ngx_int_t
-ngx_rtsig_init(ngx_cycle_t *cycle)
+ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
     ngx_rtsig_conf_t  *rtscf;
 
@@ -144,6 +146,7 @@
     sigaddset(&set, rtscf->signo);
     sigaddset(&set, rtscf->signo + 1);
     sigaddset(&set, SIGIO);
+    sigaddset(&set, SIGALRM);
 
     if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
@@ -279,59 +282,19 @@
 
 
 static ngx_int_t
-ngx_rtsig_process_events(ngx_cycle_t *cycle)
+ngx_rtsig_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
 {
     int                 signo;
     ngx_int_t           instance;
-    ngx_msec_t          timer, delta;
+    ngx_msec_t          delta;
     ngx_err_t           err;
     siginfo_t           si;
     ngx_event_t        *rev, *wev;
-    struct timeval      tv;
     struct timespec     ts, *tp;
     struct sigaction    sa;
     ngx_connection_t   *c;
     ngx_rtsig_conf_t   *rtscf;
 
-    if (overflow) {
-        timer = 0;
-
-    } else {
-        timer = ngx_event_find_timer();
-
-#if (NGX_THREADS)
-
-        if (timer == NGX_TIMER_ERROR) {
-            return NGX_ERROR;
-        }
-
-        if (timer == NGX_TIMER_INFINITE || timer > 500) {
-            timer = 500;
-        }
-
-#endif
-
-        if (ngx_accept_mutex) {
-            if (ngx_accept_disabled > 0) {
-                ngx_accept_disabled--;
-
-            } else {
-                ngx_accept_mutex_held = 0;
-
-                if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
-                    return NGX_ERROR;
-                }
-
-                if (ngx_accept_mutex_held == 0
-                    && (timer == NGX_TIMER_INFINITE
-                        || timer > ngx_accept_mutex_delay))
-                {
-                    timer = ngx_accept_mutex_delay;
-                } 
-            }
-        }
-    }
-
     if (timer == NGX_TIMER_INFINITE) {
         tp = NULL;
 
@@ -357,7 +320,6 @@
         if (err == NGX_EAGAIN) {
 
             if (timer == NGX_TIMER_INFINITE) {
-                ngx_accept_mutex_unlock();
                 ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
                               "sigtimedwait() returned EAGAIN without timeout");
                 return NGX_ERROR;
@@ -373,21 +335,20 @@
                        signo, si.si_fd, si.si_band);
     }
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
-
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    delta = ngx_current_msec;
+    
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
+    }
 
     if (err) {
-        ngx_accept_mutex_unlock();
         ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
                       cycle->log, err, "sigtimedwait() failed");
         return NGX_ERROR;
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "rtsig timer: %M, delta: %M", timer, delta);
@@ -404,9 +365,8 @@
         c = ngx_cycle->files[si.si_fd];
 
         if (c == NULL) {
-            /* the stale event */
 
-            ngx_accept_mutex_unlock();
+            /* the stale event */
 
             return NGX_OK;
         }
@@ -415,84 +375,36 @@
 
         rev = c->read;
 
-        if (c->read->instance != instance) {
+        if (rev->instance != instance) {
 
             /*
              * the stale event from a file descriptor
              * that was just closed in this iteration
              */
 
-            ngx_accept_mutex_unlock();
-
             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                            "rtsig: stale event %p", c);
 
             return NGX_OK;
         }
 
-        if (si.si_band & (POLLIN|POLLHUP|POLLERR)) {
-            if (rev->active) {
-
-                if (ngx_threaded && !rev->accept) {
-                    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                        ngx_accept_mutex_unlock();
-                        return NGX_ERROR;
-                    }
-
-                    rev->posted_ready = 1;
-                    ngx_post_event(rev);
-
-                    ngx_mutex_unlock(ngx_posted_events_mutex);
-
-                } else {
-                    rev->ready = 1;
-
-                    if (!ngx_threaded && !ngx_accept_mutex_held) {
-                        rev->handler(rev);
-
-                    } else if (rev->accept) {
-                        if (ngx_accept_disabled <= 0) {
-                            rev->handler(rev);
-                        }
-
-                    } else {
-                        ngx_post_event(rev); 
-                    }
-                }
-            }
+        if ((si.si_band & (POLLIN|POLLHUP|POLLERR)) && rev->active) {
+            rev->ready = 1;
+            rev->handler(rev);
         }
 
         wev = c->write;
 
-        if (si.si_band & (POLLOUT|POLLHUP|POLLERR)) {
-            if (wev->active) {
-
-                if (ngx_threaded) {
-                    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                        ngx_accept_mutex_unlock();
-                        return NGX_ERROR;
-                    }
-
-                    wev->posted_ready = 1;
-                    ngx_post_event(wev);
-
-                    ngx_mutex_unlock(ngx_posted_events_mutex);
-
-                } else {
-                    wev->ready = 1;
-
-                    if (!ngx_threaded && !ngx_accept_mutex_held) {
-                        wev->handler(wev);
-
-                    } else {
-                        ngx_post_event(wev);
-                    }
-                }
-            }
+        if ((si.si_band & (POLLOUT|POLLHUP|POLLERR)) && wev->active) {
+            wev->ready = 1;
+            wev->handler(wev);
         }
 
+    } else if (signo == SIGALRM) {
+
+        return NGX_OK;
+
     } else if (signo == SIGIO) {
-        ngx_accept_mutex_unlock();
 
         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                       "rt signal queue overflowed");
@@ -520,48 +432,35 @@
         return NGX_ERROR;
 
     } else if (signo != -1) {
-        ngx_accept_mutex_unlock();
-
         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                       "sigtimedwait() returned unexpected signal: %d", signo);
 
         return NGX_ERROR;
     }
 
-    ngx_accept_mutex_unlock();
-
-    ngx_event_expire_timers();
-
-    if (ngx_posted_events) {
-        if (ngx_threaded) {
-            ngx_wakeup_worker_thread(cycle);
-
-        } else {
-            ngx_event_process_posted(cycle);
-        }
-    }
-
-    if (signo == -1) {
-        return NGX_AGAIN;
-    } else {
+    if (signo != -1) {
         return NGX_OK;
     }
+
+    return NGX_AGAIN;
 }
 
 
-/* TODO: old cylces */
-
 static ngx_int_t
-ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
+ngx_rtsig_process_overflow(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags)
 {
     int                name[2], rtsig_max, rtsig_nr, events, ready;
     size_t             len;
     ngx_int_t          tested, n, i;
     ngx_err_t          err;
-    ngx_event_t       *rev, *wev;
+    ngx_event_t       *rev, *wev, **queue;
     ngx_connection_t  *c;
     ngx_rtsig_conf_t  *rtscf;
 
+    ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                   "rtsig process overflow");
+
     rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
 
     tested = 0;
@@ -608,6 +507,9 @@
         for ( ;; ) {
             ready = poll(overflow_list, n, 0);
 
+            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                           "rtsig overflow poll:%d", ready);
+
             if (ready == -1) {
                 err = ngx_errno;
                 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
@@ -626,9 +528,7 @@
             continue;
         }
 
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            return NGX_ERROR;
-        }
+        ngx_mutex_lock(ngx_posted_events_mutex);
 
         for (i = 0; i < n; i++) {
             c = cycle->files[overflow_list[i].fd];
@@ -647,13 +547,21 @@
             {
                 tested++;
 
-                if (ngx_threaded) {
+                if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
                     rev->posted_ready = 1;
-                    ngx_post_event(rev);
 
                 } else {
                     rev->ready = 1;
-                    rev->handler(rev); 
+                }
+
+                if (flags & NGX_POST_EVENTS) {
+                    queue = (ngx_event_t **) (rev->accept ?
+                               &ngx_posted_accept_events : &ngx_posted_events);
+
+                    ngx_locked_post_event(rev, queue);
+
+                } else {
+                    rev->handler(rev);
                 }
             }
 
@@ -667,13 +575,18 @@
             {
                 tested++;
 
-                if (ngx_threaded) {
+                if (flags & NGX_POST_THREAD_EVENTS) {
                     wev->posted_ready = 1;
-                    ngx_post_event(wev);
 
                 } else {
                     wev->ready = 1;
-                    wev->handler(wev); 
+                }
+
+                if (flags & NGX_POST_EVENTS) {
+                    ngx_locked_post_event(wev, &ngx_posted_events);
+
+                } else {
+                    wev->handler(wev);
                 }
             }
         }
@@ -688,8 +601,8 @@
                  * Check the current rt queue length to prevent
                  * the new overflow.
                  *
-                 * Learn the /proc/sys/kernel/rtsig-max value because
-                 * it can be changed since the last checking.
+                 * learn the "/proc/sys/kernel/rtsig-max" value because
+                 * it can be changed since the last checking
                  */
 
                 name[0] = CTL_KERN;
@@ -713,16 +626,17 @@
                 }
 
                 /*
-                 * drain the rt signal queue if the /proc/sys/kernel/rtsig-nr
+                 * drain the rt signal queue if the /"proc/sys/kernel/rtsig-nr"
                  * is bigger than
-                 *    /proc/sys/kernel/rtsig-max / rtsig_overflow_threshold
+                 *    "/proc/sys/kernel/rtsig-max" / "rtsig_overflow_threshold"
                  */
 
                 if (rtsig_max / rtscf->overflow_threshold < rtsig_nr) {
                     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                                    "rtsig queue state: %d/%d",
                                    rtsig_nr, rtsig_max);
-                    while (ngx_rtsig_process_events(cycle) == NGX_OK) {
+                    while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK)
+                    {
                         /* void */
                     }
                 }
@@ -734,20 +648,17 @@
                  * so drain the rt signal queue unconditionally
                  */
 
-                while (ngx_rtsig_process_events(cycle) == NGX_OK) { /* void */ }
+                while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK) {
+                    /* void */
+                }
             }
 
             tested = 0;
         }
     }
 
-    if (ngx_posted_events) {
-        if (ngx_threaded) {
-            ngx_wakeup_worker_thread(cycle);
-
-        } else {
-            ngx_event_process_posted(cycle);
-        }
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
     }
 
     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
diff --git a/src/event/modules/ngx_select_module.c b/src/event/modules/ngx_select_module.c
index 5be3afa..da4303d 100644
--- a/src/event/modules/ngx_select_module.c
+++ b/src/event/modules/ngx_select_module.c
@@ -10,11 +10,12 @@
 
 
 
-static ngx_int_t ngx_select_init(ngx_cycle_t *cycle);
+static ngx_int_t ngx_select_init(ngx_cycle_t *cycle, ngx_msec_t timer);
 static void ngx_select_done(ngx_cycle_t *cycle);
 static ngx_int_t ngx_select_add_event(ngx_event_t *ev, int event, u_int flags);
 static ngx_int_t ngx_select_del_event(ngx_event_t *ev, int event, u_int flags);
-static ngx_int_t ngx_select_process_events(ngx_cycle_t *cycle);
+static ngx_int_t ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags);
 static char *ngx_select_init_conf(ngx_cycle_t *cycle, void *conf);
 
 
@@ -33,11 +34,6 @@
 static ngx_uint_t     nevents;
 
 static ngx_event_t  **event_index;
-#if 0
-static ngx_event_t  **ready_index;
-#endif
-
-static ngx_event_t   *accept_events;
 
 
 static ngx_str_t    select_name = ngx_string("select");
@@ -79,7 +75,7 @@
 
 
 static ngx_int_t
-ngx_select_init(ngx_cycle_t *cycle)
+ngx_select_init(ngx_cycle_t *cycle, ngx_msec_t timer)
 {
     ngx_event_t  **index;
 
@@ -103,26 +99,15 @@
             ngx_memcpy(index, event_index, sizeof(ngx_event_t *) * nevents);
             ngx_free(event_index);
         }
+
         event_index = index;
-
-#if 0
-        if (ready_index) {
-            ngx_free(ready_index);
-        }
-
-        ready_index = ngx_alloc(sizeof(ngx_event_t *) * 2 * cycle->connection_n,
-                                cycle->log);
-        if (ready_index == NULL) {
-            return NGX_ERROR;
-        }
-#endif
     }
 
     ngx_io = ngx_os_io;
 
     ngx_event_actions = ngx_select_module_ctx.actions;
 
-    ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_ONESHOT_EVENT;
+    ngx_event_flags = NGX_USE_LEVEL_EVENT;
 
 #if (NGX_WIN32)
     max_read = max_write = 0;
@@ -138,9 +123,6 @@
 ngx_select_done(ngx_cycle_t *cycle)
 {
     ngx_free(event_index);
-#if 0
-    ngx_free(ready_index);
-#endif
 
     event_index = NULL;
 }
@@ -262,41 +244,22 @@
 
 
 static ngx_int_t
-ngx_select_process_events(ngx_cycle_t *cycle)
+ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
+    ngx_uint_t flags)
 {
-    int                       ready, nready;
-    ngx_uint_t                i, found, lock;
-    ngx_err_t                 err;
-    ngx_msec_t                timer, delta;
-    ngx_event_t              *ev;
-    ngx_connection_t         *c;
-    struct timeval            tv, *tp;
-#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
-    static ngx_msec_t         deltas = 0;
+    int                 ready, nready;
+    ngx_uint_t          i, found;
+    ngx_err_t           err;
+    ngx_msec_t          delta;
+    ngx_event_t        *ev, **queue;
+    ngx_connection_t   *c;
+    struct timeval      tv, *tp;
+#if !(NGX_WIN32)
+    ngx_uint_t          level;
 #endif
 
-    timer = ngx_event_find_timer();
-
 #if !(NGX_WIN32)
 
-    if (ngx_accept_mutex) {
-        if (ngx_accept_disabled > 0) {
-            ngx_accept_disabled--;
-
-        } else {
-            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            if (ngx_accept_mutex_held == 0
-                && (timer == NGX_TIMER_INFINITE
-                    || timer > ngx_accept_mutex_delay))
-            {
-                timer = ngx_accept_mutex_delay;
-            }
-        }
-    }
-
     if (max_fd == -1) {
         for (i = 0; i < nevents; i++) {
             c = event_index[i]->data;
@@ -353,9 +316,13 @@
 #endif
 
 #if (NGX_WIN32)
+
     ready = select(0, &work_read_fd_set, &work_write_fd_set, NULL, tp);
+
 #else
+
     ready = select(max_fd + 1, &work_read_fd_set, &work_write_fd_set, NULL, tp);
+
 #endif
 
     if (ready == -1) {
@@ -364,58 +331,14 @@
         err = 0;
     }
 
-#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
+    delta = ngx_current_msec;
 
-    if (timer != NGX_TIMER_INFINITE) {
-        delta = timer - ((ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000);
-
-        /*
-         * learn the real time and update the cached time
-         * if the sum of the last deltas overcomes 1 second
-         */
-
-        deltas += delta;
-        if (deltas > 1000) {
-            ngx_gettimeofday(&tv);
-            ngx_time_update(tv.tv_sec);
-            deltas = tv.tv_usec / 1000;
-
-            ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000
-                                                           + tv.tv_usec / 1000;
-        } else {
-            ngx_current_time += delta;
-        }
-
-        ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "select timer: %M, delta: %M", timer, delta);
-
-    } else {
-        deltas = 0;
-
-        ngx_gettimeofday(&tv);
-        ngx_time_update(tv.tv_sec);
-
-        delta = ngx_current_time;
-        ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
-
-        if (ready == 0) {
-            ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
-                          "select() returned no events without timeout");
-            ngx_accept_mutex_unlock();
-            return NGX_ERROR;
-        }
+    if (flags & NGX_UPDATE_TIME) {
+        ngx_time_update(0, 0);
     }
 
-#else /* !(NGX_HAVE_SELECT_CHANGE_TIMEOUT) */
-
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
-
-    delta = ngx_current_time;
-    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
-
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_current_time - delta;
+        delta = ngx_current_msec - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                        "select timer: %M, delta: %M", timer, delta);
@@ -424,34 +347,48 @@
         if (ready == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                           "select() returned no events without timeout");
-            ngx_accept_mutex_unlock();
             return NGX_ERROR;
         }
     }
 
-#endif /* NGX_HAVE_SELECT_CHANGE_TIMEOUT */
-
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "select ready %d", ready);
 
-    if (err) {
 #if (NGX_WIN32)
+
+    if (err) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, err, "select() failed");
+        return NGX_ERROR;
+    }
+
 #else
-        ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
-                      cycle->log, err, "select() failed");
+
+    if (err) {
+        if (err == NGX_EINTR) {
+
+            if (ngx_event_timer_alarm) {
+                ngx_event_timer_alarm = 0;
+                return NGX_OK;
+            }
+ 
+            level = NGX_LOG_INFO;
+ 
+        } else { 
+            level = NGX_LOG_ALERT;
+        }
+
+        ngx_log_error(level, cycle->log, err, "select() failed");
+        return NGX_ERROR;
+    }
+
 #endif
-        ngx_accept_mutex_unlock();
-        return NGX_ERROR;
+
+    if (nevents == 0) {
+        return NGX_OK;
     }
 
+    ngx_mutex_lock(ngx_posted_events_mutex);
 
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        ngx_accept_mutex_unlock();
-        return NGX_ERROR;
-    }
-
-    lock = 1;
     nready = 0;
 
     for (i = 0; i < nevents; i++) {
@@ -477,110 +414,20 @@
         if (found) {
             ev->ready = 1;
 
-            if (ev->oneshot) {
-                if (ev->timer_set) {
-                    ngx_del_timer(ev);
-                }
-
-                if (ev->write) {
-                    ngx_select_del_event(ev, NGX_WRITE_EVENT, 0);
-                } else {
-                    ngx_select_del_event(ev, NGX_READ_EVENT, 0);
-                }
-            }
-
-            if (ev->accept) {
-                ev->next = accept_events;
-                accept_events = ev;
-            } else {
-                ngx_post_event(ev);
-            }
+            queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
+                                                   &ngx_posted_events);
+            ngx_locked_post_event(ev, queue); 
 
             nready++;
-
-#if 0
-            ready_index[nready++] = ev;
-#endif
         }
     }
 
-#if 0
-    for (i = 0; i < nready; i++) {
-        ev = ready_index[i];
-        ready--;
-
-        if (!ev->active) {
-            continue;
-        }
-
-        ev->ready = 1;
-
-        if (ev->oneshot) {
-            if (ev->timer_set) {
-                ngx_del_timer(ev);
-            }
-
-            if (ev->write) {
-                ngx_select_del_event(ev, NGX_WRITE_EVENT, 0);
-            } else {
-                ngx_select_del_event(ev, NGX_READ_EVENT, 0);
-            }
-        }
-
-        ev->handler(ev);
-    }
-#endif
-
-    ev = accept_events;
-
-    for ( ;; ) {
-
-        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                      "accept event %p", ev);
-
-        if (ev == NULL) {
-            break;
-        }
-
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-
-        ev->handler(ev);
-
-        if (ngx_accept_disabled > 0) {
-            lock = 0;
-            break;
-        }
-
-        ev = ev->next;
-
-        if (ev == NULL) {
-            lock = 0;
-            break;
-        }
-
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            ngx_accept_mutex_unlock();
-            return NGX_ERROR;
-        }
-    }
-
-    ngx_accept_mutex_unlock();
-    accept_events = NULL;
-
-    if (lock) {
-        ngx_mutex_unlock(ngx_posted_events_mutex);
-    }
+    ngx_mutex_unlock(ngx_posted_events_mutex);
 
     if (ready != nready) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "select ready != events");
     }
 
-    ngx_event_expire_timers();
-
-    if (!ngx_threaded) {
-        ngx_event_process_posted(cycle);
-    }
-
     return NGX_OK;
 }
 
@@ -599,19 +446,25 @@
     /* disable warning: the default FD_SETSIZE is 1024U in FreeBSD 5.x */
 
 #if !(NGX_WIN32)
+
     if ((unsigned) ecf->connections > FD_SETSIZE) {
         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
                       "the maximum number of files "
                       "supported by select() is " ngx_value(FD_SETSIZE));
         return NGX_CONF_ERROR;
     }
+
 #endif
 
 #if (NGX_THREADS) && !(NGX_WIN32)
+
     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
                   "select() is not supported in the threaded mode");
     return NGX_CONF_ERROR;
+
 #else
+
     return NGX_CONF_OK;
+
 #endif
 }
diff --git a/src/event/ngx_event.c b/src/event/ngx_event.c
index 2e2a065..6dc6e3c 100644
--- a/src/event/ngx_event.c
+++ b/src/event/ngx_event.c
@@ -34,6 +34,9 @@
 static char *ngx_accept_mutex_check(ngx_conf_t *cf, void *post, void *data);
 
 
+static ngx_uint_t     ngx_timer_resolution;
+sig_atomic_t          ngx_event_timer_alarm;
+
 static ngx_uint_t     ngx_event_max_module;
 
 ngx_uint_t            ngx_event_flags;
@@ -192,6 +195,77 @@
 };
 
 
+void
+ngx_process_events_and_timers(ngx_cycle_t *cycle)
+{
+    ngx_uint_t  flags;
+    ngx_msec_t  timer;
+
+    if (ngx_timer_resolution) {
+        timer = NGX_TIMER_INFINITE;
+        flags = 0;
+
+    } else {
+        timer = ngx_event_find_timer();
+        flags = NGX_UPDATE_TIME;
+
+#if (NGX_THREADS)
+
+        if (timer == NGX_TIMER_INFINITE || timer > 500) {
+            timer = 500;
+        }
+
+#endif
+    }
+
+    if (ngx_accept_mutex) {
+        if (ngx_accept_disabled > 0) {
+            ngx_accept_disabled--;
+
+        } else {
+            if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
+                return;
+            }
+
+            if (ngx_accept_mutex_held) {
+                flags |= NGX_POST_EVENTS;
+
+            } else {
+                if (timer == NGX_TIMER_INFINITE
+                    || timer > ngx_accept_mutex_delay)
+                {
+                    timer = ngx_accept_mutex_delay;
+                }
+            }
+        }
+    }
+
+    (void) ngx_process_events(cycle, timer, flags);
+
+    ngx_event_expire_timers();
+
+    if (ngx_posted_accept_events) {
+        ngx_event_process_posted(cycle, &ngx_posted_accept_events);
+    }
+
+    if (ngx_accept_mutex_held) {
+        ngx_accept_mutex = 0;
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                   "posted events %p", ngx_posted_events);
+
+    if (ngx_posted_events) {
+        if (ngx_threaded) {
+            ngx_wakeup_worker_thread(cycle);
+
+        } else {
+            ngx_event_process_posted(cycle, &ngx_posted_events);
+        }
+    }
+}
+
+
 ngx_int_t
 ngx_handle_read_event(ngx_event_t *rev, u_int flags)
 {
@@ -332,12 +406,12 @@
 {
     void              ***cf;
     ngx_event_conf_t    *ecf;
+    ngx_core_conf_t     *ccf;
 #if !(NGX_WIN32)
     char                *shared;
     size_t               size;
     ngx_int_t            limit;
     struct rlimit        rlmt;
-    ngx_core_conf_t     *ccf;
 #endif
 
     cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);
@@ -353,10 +427,12 @@
     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
                   "using the \"%s\" event method", ecf->name);
 
-#if !(NGX_WIN32)
-
     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
 
+    ngx_timer_resolution = ccf->timer_resolution;
+
+#if !(NGX_WIN32)
+
     if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                       "getrlimit(RLIMIT_NOFILE) failed, ignored");
@@ -417,6 +493,8 @@
 
 #endif
 
+    *ngx_connection_counter = 1;
+
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "counter: %p, %d",
                    ngx_connection_counter, *ngx_connection_counter);
@@ -427,6 +505,23 @@
 }
 
 
+#if !(NGX_WIN32)
+
+void
+ngx_timer_signal_handler(int signo)
+{
+    ngx_event_timer_alarm = 1;
+
+    ngx_time_update(0, 0);
+
+#if 1
+    ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer signal");
+#endif
+}
+
+#endif
+
+
 static ngx_int_t
 ngx_event_process_init(ngx_cycle_t *cycle)
 {
@@ -441,6 +536,8 @@
     ngx_iocp_conf_t     *iocpcf;
 #else
     struct rlimit        rlmt;
+    struct sigaction     sa;
+    struct itimerval     itv;
 #endif
 
     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
@@ -473,7 +570,8 @@
 
         if (ngx_modules[m]->ctx_index == ecf->use) {
             module = ngx_modules[m]->ctx;
-            if (module->actions.init(cycle) == NGX_ERROR) {
+            if (module->actions.init(cycle, ngx_timer_resolution) == NGX_ERROR)
+            {
                 /* fatal */
                 exit(2);
             }
@@ -483,6 +581,29 @@
 
 #if !(NGX_WIN32)
 
+    if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
+
+        ngx_memzero(&sa, sizeof(struct sigaction));
+        sa.sa_handler = ngx_timer_signal_handler;
+        sigemptyset(&sa.sa_mask);
+
+        if (sigaction(SIGALRM, &sa, NULL) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                          "sigaction(SIGALRM) failed");
+            return NGX_ERROR;
+        }
+
+        itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
+        itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
+        itv.it_value.tv_sec = ngx_timer_resolution / 1000;
+        itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;
+
+        if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                          "setitimer() failed");
+        } 
+    }
+
     if (ngx_event_flags & NGX_USE_FD_EVENT) {
 
         if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
diff --git a/src/event/ngx_event.h b/src/event/ngx_event.h
index 9d917ea..af3e4a4 100644
--- a/src/event/ngx_event.h
+++ b/src/event/ngx_event.h
@@ -134,6 +134,9 @@
 
     unsigned         closed:1;
 
+    /* to test on worker exit */
+    unsigned         channel:1;
+
 #if (NGX_THREADS)
 
     unsigned         locked:1;
@@ -196,9 +199,10 @@
     ngx_int_t  (*del_conn)(ngx_connection_t *c, u_int flags);
 
     ngx_int_t  (*process_changes)(ngx_cycle_t *cycle, ngx_uint_t nowait);
-    ngx_int_t  (*process_events)(ngx_cycle_t *cycle);
+    ngx_int_t  (*process_events)(ngx_cycle_t *cycle, ngx_msec_t timer,
+                   ngx_uint_t flags);
 
-    ngx_int_t  (*init)(ngx_cycle_t *cycle);
+    ngx_int_t  (*init)(ngx_cycle_t *cycle, ngx_msec_t timer);
     void       (*done)(ngx_cycle_t *cycle);
 } ngx_event_actions_t;
 
@@ -214,7 +218,7 @@
 
 /*
  * The event filter is deleted after a notification without an additional
- * syscall: select, poll, kqueue, epoll, Solaris 10's event ports.
+ * syscall: kqueue, epoll, Solaris 10's event ports.
  */
 #define NGX_USE_ONESHOT_EVENT    0x00000002
 
@@ -270,6 +274,12 @@
  */
 #define NGX_USE_FD_EVENT         0x00000400
 
+/*
+ * The event module handles periodic or absolute timer event by itself:
+ * kqueue in FreeBSD 4.4 and NetBSD 2.0, Solaris 10's event ports.
+ */
+#define NGX_USE_TIMER_EVENT      0x00000800
+
 
 
 /*
@@ -446,13 +456,12 @@
 #endif
 
 
-
-#define ngx_accept_mutex_unlock()                                             \
-           if (ngx_accept_mutex_held) {                                       \
-               *ngx_accept_mutex = 0;                                         \
-           }
+#define NGX_UPDATE_TIME         1
+#define NGX_POST_EVENTS         2
+#define NGX_POST_THREAD_EVENTS  4
 
 
+extern sig_atomic_t           ngx_event_timer_alarm;
 extern ngx_uint_t             ngx_event_flags;
 extern ngx_module_t           ngx_events_module;
 extern ngx_module_t           ngx_event_core_module;
@@ -470,6 +479,7 @@
 u_char *ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len);
 
 
+void ngx_process_events_and_timers(ngx_cycle_t *cycle);
 ngx_int_t ngx_handle_read_event(ngx_event_t *rev, u_int flags);
 ngx_int_t ngx_handle_write_event(ngx_event_t *wev, size_t lowat);
 
diff --git a/src/event/ngx_event_acceptex.c b/src/event/ngx_event_acceptex.c
index f269844..956a3f1 100644
--- a/src/event/ngx_event_acceptex.c
+++ b/src/event/ngx_event_acceptex.c
@@ -188,7 +188,7 @@
             err = ngx_socket_errno;
             if (err != WSA_IO_PENDING) {
                 ngx_log_error(NGX_LOG_ALERT, &ls->log, err,
-                              "AcceptEx() %s falied", ls->addr_text.data);
+                              "AcceptEx() %V falied", &ls->addr_text);
 
                 ngx_close_posted_connection(c);
                 return NGX_ERROR;
diff --git a/src/event/ngx_event_busy_lock.c b/src/event/ngx_event_busy_lock.c
index 4d499a3..1b09ad9 100644
--- a/src/event/ngx_event_busy_lock.c
+++ b/src/event/ngx_event_busy_lock.c
@@ -10,7 +10,7 @@
 
 
 static int ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
-                                             ngx_event_busy_lock_ctx_t *ctx);
+    ngx_event_busy_lock_ctx_t *ctx);
 static void ngx_event_busy_lock_handler(ngx_event_t *ev);
 static void ngx_event_busy_lock_posted_handler(ngx_event_t *ev);
 
@@ -23,14 +23,12 @@
  * NGX_ERROR:  an error occured while the mutex locking
  */
 
-ngx_int_t ngx_event_busy_lock(ngx_event_busy_lock_t *bl,
-                              ngx_event_busy_lock_ctx_t *ctx)
+ngx_int_t
+ngx_event_busy_lock(ngx_event_busy_lock_t *bl, ngx_event_busy_lock_ctx_t *ctx)
 {
     ngx_int_t  rc;
 
-    if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(bl->mutex);
 
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->event->log, 0,
                    "event busy lock: b:%d mb:%d",
@@ -66,14 +64,13 @@
 }
 
 
-ngx_int_t ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
-                                       ngx_event_busy_lock_ctx_t *ctx)
+ngx_int_t
+ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
+    ngx_event_busy_lock_ctx_t *ctx)
 {
     ngx_int_t  rc;
 
-    if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(bl->mutex);
 
     rc = ngx_event_busy_lock_look_cachable(bl, ctx);
 
@@ -112,15 +109,14 @@
 }
 
 
-ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
-                                ngx_event_busy_lock_ctx_t *ctx)
+void
+ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
+    ngx_event_busy_lock_ctx_t *ctx)
 {
     ngx_event_t                *ev;
     ngx_event_busy_lock_ctx_t  *wakeup;
 
-    if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(bl->mutex);
 
     if (bl->events) {
         wakeup = bl->events;
@@ -138,7 +134,7 @@
 
     if (wakeup == NULL) {
         ngx_mutex_unlock(bl->mutex);
-        return NGX_OK;
+        return;
     }
 
     if (ctx->md5) {
@@ -152,13 +148,7 @@
 
             ev = wakeup->event;
 
-            if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            ngx_post_event(ev);
-
-            ngx_mutex_unlock(ngx_posted_events_mutex);
+            ngx_post_event(ev, &ngx_posted_events);
         }
 
         ngx_mutex_unlock(bl->mutex);
@@ -177,27 +167,18 @@
             ngx_del_timer(ev);
         }
 
-        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-            return NGX_ERROR;
-        }
-
-        ngx_post_event(ev);
-
-        ngx_mutex_unlock(ngx_posted_events_mutex);
+        ngx_post_event(ev, &ngx_posted_events);
     }
-
-    return NGX_OK;
 }
 
 
-ngx_int_t ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
-                                     ngx_event_busy_lock_ctx_t *ctx)
+void
+ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
+    ngx_event_busy_lock_ctx_t *ctx)
 {
     ngx_event_busy_lock_ctx_t  *c, *p;
 
-    if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(bl->mutex);
 
     bl->waiting--;
 
@@ -216,13 +197,12 @@
     }
 
     ngx_mutex_unlock(bl->mutex);
-
-    return NGX_OK;
 }
 
 
-static int ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
-                                             ngx_event_busy_lock_ctx_t *ctx)
+static ngx_int_t
+ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
+    ngx_event_busy_lock_ctx_t *ctx)
 {
     ngx_int_t    free;
     ngx_uint_t   i, bit, cachable, mask;
@@ -286,21 +266,17 @@
 }
 
 
-static void ngx_event_busy_lock_handler(ngx_event_t *ev)
+static void
+ngx_event_busy_lock_handler(ngx_event_t *ev)
 {
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        return;
-    }
-
-    ngx_post_event(ev);
-
-    ngx_mutex_unlock(ngx_posted_events_mutex);
-
     ev->handler = ngx_event_busy_lock_posted_handler;
+
+    ngx_post_event(ev, &ngx_posted_events);
 }
 
 
-static void ngx_event_busy_lock_posted_handler(ngx_event_t *ev)
+static void
+ngx_event_busy_lock_posted_handler(ngx_event_t *ev)
 {
     ngx_event_busy_lock_ctx_t  *ctx;
 
diff --git a/src/event/ngx_event_busy_lock.h b/src/event/ngx_event_busy_lock.h
index ce60002..5b50be6 100644
--- a/src/event/ngx_event_busy_lock.h
+++ b/src/event/ngx_event_busy_lock.h
@@ -52,13 +52,13 @@
 
 
 ngx_int_t ngx_event_busy_lock(ngx_event_busy_lock_t *bl,
-                              ngx_event_busy_lock_ctx_t *ctx);
+    ngx_event_busy_lock_ctx_t *ctx);
 ngx_int_t ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
-                                       ngx_event_busy_lock_ctx_t *ctx);
-ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
-                                ngx_event_busy_lock_ctx_t *ctx);
-ngx_int_t ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
-                                     ngx_event_busy_lock_ctx_t *ctx);
+    ngx_event_busy_lock_ctx_t *ctx);
+void ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
+    ngx_event_busy_lock_ctx_t *ctx);
+void ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
+    ngx_event_busy_lock_ctx_t *ctx);
 
 
 #endif /* _NGX_EVENT_BUSY_LOCK_H_INCLUDED_ */
diff --git a/src/event/ngx_event_connect.c b/src/event/ngx_event_connect.c
index 6182ef0..b20d16d 100644
--- a/src/event/ngx_event_connect.c
+++ b/src/event/ngx_event_connect.c
@@ -141,7 +141,8 @@
 
     if (pc->rcvbuf) {
         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
-                       (const void *) &pc->rcvbuf, sizeof(int)) == -1) {
+                       (const void *) &pc->rcvbuf, sizeof(int)) == -1)
+        {
             ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
                           "setsockopt(SO_RCVBUF) failed");
 
diff --git a/src/event/ngx_event_openssl.c b/src/event/ngx_event_openssl.c
index 48a03a1..5e8e747 100644
--- a/src/event/ngx_event_openssl.c
+++ b/src/event/ngx_event_openssl.c
@@ -105,7 +105,27 @@
         return NGX_ERROR;
     }
 
-    SSL_CTX_set_options(ssl->ctx, SSL_OP_ALL);
+    /*
+     * these options are needed on client side only:
+     *    SSL_OP_MICROSOFT_SESS_ID_BUG
+     *    SSL_OP_NETSCAPE_CHALLENGE_BUG
+     *    SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
+     */
+
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
+
+    /* this option allow a potential SSL 2.0 rollback (CAN-2005-2969) */
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_MSIE_SSLV2_RSA_PADDING);
+
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_D5_BUG);
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
+
+#ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
+    SSL_CTX_set_options(ssl->ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
+#endif
+
 
     if (ngx_ssl_protocols[protocols >> 1] != 0) {
         SSL_CTX_set_options(ssl->ctx, ngx_ssl_protocols[protocols >> 1]);
@@ -120,20 +140,31 @@
 
 
 ngx_int_t
-ngx_ssl_certificate(ngx_ssl_t *ssl, u_char *cert, u_char *key)
+ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
+    ngx_str_t *key)
 {
-    if (SSL_CTX_use_certificate_chain_file(ssl->ctx, (char *) cert) == 0) {
-        ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
-                      "SSL_CTX_use_certificate_chain_file(\"%s\") failed",
-                      cert);
+    if (ngx_conf_full_name(cf->cycle, cert) == NGX_ERROR) {
         return NGX_ERROR;
     }
 
-    if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key, SSL_FILETYPE_PEM)
+    if (SSL_CTX_use_certificate_chain_file(ssl->ctx, (char *) cert->data)
         == 0)
     {
         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
-                      "SSL_CTX_use_PrivateKey_file(\"%s\") failed", key);
+                      "SSL_CTX_use_certificate_chain_file(\"%s\") failed",
+                      cert->data);
+        return NGX_ERROR;
+    }
+
+    if (ngx_conf_full_name(cf->cycle, key) == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key->data,
+                                    SSL_FILETYPE_PEM) == 0)
+    {
+        ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
+                      "SSL_CTX_use_PrivateKey_file(\"%s\") failed", key->data);
         return NGX_ERROR;
     }
 
@@ -402,13 +433,7 @@
                 return NGX_ERROR;
             }
 
-            if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            ngx_post_event(c->write);
-
-            ngx_mutex_unlock(ngx_posted_events_mutex);
+            ngx_post_event(c->write, &ngx_posted_events);
         }
 
         return NGX_OK;
@@ -632,13 +657,7 @@
                 return NGX_ERROR;
             }
 
-            if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
-
-            ngx_post_event(c->read);
-
-            ngx_mutex_unlock(ngx_posted_events_mutex);
+            ngx_post_event(c->read, &ngx_posted_events);
         }
 
         return n;
@@ -925,8 +944,8 @@
 ngx_openssl_noengine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 {
     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
-                       "\"ssl_engine\" is not supported: " NGX_SSL_NAME
-                       " library does not support crypto accelerators");
+                       "\"ssl_engine\" directive is available only in "
+                       "OpenSSL 0.9.7 and higher,");
 
     return NGX_CONF_ERROR;
 }
diff --git a/src/event/ngx_event_openssl.h b/src/event/ngx_event_openssl.h
index cd3898c..6e81cdf 100644
--- a/src/event/ngx_event_openssl.h
+++ b/src/event/ngx_event_openssl.h
@@ -58,7 +58,8 @@
 
 ngx_int_t ngx_ssl_init(ngx_log_t *log);
 ngx_int_t ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols);
-ngx_int_t ngx_ssl_certificate(ngx_ssl_t *ssl, u_char *cert, u_char *key);
+ngx_int_t ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
+    ngx_str_t *cert, ngx_str_t *key);
 ngx_int_t ngx_ssl_generate_rsa512_key(ngx_ssl_t *ssl);
 ngx_int_t ngx_ssl_create_connection(ngx_ssl_t *ssl, ngx_connection_t *c,
     ngx_uint_t flags);
diff --git a/src/event/ngx_event_posted.c b/src/event/ngx_event_posted.c
index 181ab4c..a7b09fd 100644
--- a/src/event/ngx_event_posted.c
+++ b/src/event/ngx_event_posted.c
@@ -9,6 +9,7 @@
 #include <ngx_event.h>
 
 
+ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
 ngx_thread_volatile ngx_event_t  *ngx_posted_events;
 
 #if (NGX_THREADS)
@@ -16,13 +17,15 @@
 #endif
 
 
-void ngx_event_process_posted(ngx_cycle_t *cycle)
+void
+ngx_event_process_posted(ngx_cycle_t *cycle,
+    ngx_thread_volatile ngx_event_t **posted)
 {
     ngx_event_t  *ev;
 
     for ( ;; ) {
 
-        ev = (ngx_event_t *) ngx_posted_events;
+        ev = (ngx_event_t *) *posted;
 
         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                       "posted event %p", ev);
@@ -40,7 +43,8 @@
 
 #if (NGX_THREADS) && !(NGX_WIN32)
 
-void ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
+void
+ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
 {
     ngx_int_t     i;
 #if 0
@@ -76,7 +80,8 @@
 }
 
 
-ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle)
+ngx_int_t
+ngx_event_thread_process_posted(ngx_cycle_t *cycle)
 {
     ngx_event_t  *ev;
 
@@ -139,9 +144,7 @@
 
             ev->handler(ev);
 
-            if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                return NGX_ERROR;
-            }
+            ngx_mutex_lock(ngx_posted_events_mutex);
 
             if (ev->locked) {
                 ngx_unlock(ev->lock);
@@ -161,7 +164,8 @@
 
 #else
 
-void ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
+void
+ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
 {
 }
 
diff --git a/src/event/ngx_event_posted.h b/src/event/ngx_event_posted.h
index 86100af..f9c55e5 100644
--- a/src/event/ngx_event_posted.h
+++ b/src/event/ngx_event_posted.h
@@ -13,43 +13,62 @@
 #include <ngx_event.h>
 
 
-#define ngx_post_event(ev)                                                    \
-            if (ev->prev == NULL) {                                           \
-                ev->next = (ngx_event_t *) ngx_posted_events;                 \
-                ev->prev = (ngx_event_t **) &ngx_posted_events;               \
-                ngx_posted_events = ev;                                       \
-                if (ev->next) {                                               \
-                    ev->next->prev = &ev->next;                               \
-                }                                                             \
-                ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                \
-                               "post event %p", ev);                          \
-            } else  {                                                         \
-                ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                \
-                               "update posted event %p", ev);                 \
-            }
+#if (NGX_THREADS)
+extern ngx_mutex_t  *ngx_posted_events_mutex;
+#endif
+
+
+#define ngx_locked_post_event(ev, queue)                                      \
+                                                                              \
+    if (ev->prev == NULL) {                                                   \
+        ev->next = (ngx_event_t *) *queue;                                    \
+        ev->prev = (ngx_event_t **) queue;                                    \
+        *queue = ev;                                                          \
+                                                                              \
+        if (ev->next) {                                                       \
+            ev->next->prev = &ev->next;                                       \
+        }                                                                     \
+                                                                              \
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0, "post event %p", ev);  \
+                                                                              \
+    } else  {                                                                 \
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                        \
+                       "update posted event %p", ev);                         \
+    }
+
+
+#define ngx_post_event(ev, queue)                                             \
+                                                                              \
+    ngx_mutex_lock(ngx_posted_events_mutex);                                  \
+    ngx_locked_post_event(ev, queue);                                         \
+    ngx_mutex_unlock(ngx_posted_events_mutex);
+
 
 #define ngx_delete_posted_event(ev)                                           \
-        *(ev->prev) = ev->next;                                               \
-        if (ev->next) {                                                       \
-            ev->next->prev = ev->prev;                                        \
-        }                                                                     \
-        ev->prev = NULL;                                                      \
-        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                        \
-                       "delete posted event %p", ev);
+                                                                              \
+    *(ev->prev) = ev->next;                                                   \
+                                                                              \
+    if (ev->next) {                                                           \
+        ev->next->prev = ev->prev;                                            \
+    }                                                                         \
+                                                                              \
+    ev->prev = NULL;                                                          \
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                            \
+                   "delete posted event %p", ev);
 
 
 
-void ngx_event_process_posted(ngx_cycle_t *cycle);
+void ngx_event_process_posted(ngx_cycle_t *cycle,
+    ngx_thread_volatile ngx_event_t **posted);
 void ngx_wakeup_worker_thread(ngx_cycle_t *cycle);
 
-extern ngx_thread_volatile ngx_event_t  *ngx_posted_events;
-
-
 #if (NGX_THREADS)
 ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle);
-
-extern ngx_mutex_t                      *ngx_posted_events_mutex;
 #endif
 
 
+extern ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
+extern ngx_thread_volatile ngx_event_t  *ngx_posted_events;
+
+
 #endif /* _NGX_EVENT_POSTED_H_INCLUDED_ */
diff --git a/src/event/ngx_event_timer.c b/src/event/ngx_event_timer.c
index 174cc65..3eb23f6 100644
--- a/src/event/ngx_event_timer.c
+++ b/src/event/ngx_event_timer.c
@@ -52,9 +52,7 @@
         return NGX_TIMER_INFINITE;
     }
 
-    if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
-        return NGX_TIMER_ERROR;
-    }
+    ngx_mutex_lock(ngx_event_timer_mutex);
 
     root = ngx_event_timer_rbtree.root;
     sentinel = ngx_event_timer_rbtree.sentinel;
@@ -63,7 +61,7 @@
 
     ngx_mutex_unlock(ngx_event_timer_mutex);
 
-    timer = (ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_time;
+    timer = (ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec;
 
     return (ngx_msec_t) (timer > 0 ? timer : 0);
 }
@@ -79,9 +77,7 @@
 
     for ( ;; ) {
 
-        if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
-            return;
-        }
+        ngx_mutex_lock(ngx_event_timer_mutex);
 
         root = ngx_event_timer_rbtree.root;
 
@@ -93,7 +89,7 @@
 
         /* node->key <= ngx_current_time */
 
-        if ((ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_time <= 0)
+        if ((ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec <= 0)
         {
             ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));
 
@@ -133,14 +129,9 @@
 
 #if (NGX_THREADS)
             if (ngx_threaded) {
-                if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-                    return;
-                }
-
                 ev->posted_timedout = 1;
-                ngx_post_event(ev);
 
-                ngx_mutex_unlock(ngx_posted_events_mutex);
+                ngx_post_event(ev, &ngx_posted_events);
 
                 ngx_unlock(ev->lock);
 
diff --git a/src/event/ngx_event_timer.h b/src/event/ngx_event_timer.h
index f980234..ce32ce9 100644
--- a/src/event/ngx_event_timer.h
+++ b/src/event/ngx_event_timer.h
@@ -14,7 +14,6 @@
 
 
 #define NGX_TIMER_INFINITE  (ngx_msec_t) -1
-#define NGX_TIMER_ERROR     (ngx_msec_t) -2
 
 #define NGX_TIMER_LAZY_DELAY  300
 
@@ -39,9 +38,7 @@
                    "event timer del: %d: %M",
                     ngx_event_ident(ev->data), ev->timer.key);
 
-    if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
-        return;
-    }
+    ngx_mutex_lock(ngx_event_timer_mutex);
 
     ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);
 
@@ -63,7 +60,7 @@
     ngx_msec_t      key;
     ngx_msec_int_t  diff;
 
-    key = ngx_current_time + timer;
+    key = ngx_current_msec + timer;
 
     if (ev->timer_set) {
 
@@ -91,9 +88,7 @@
                    "event timer add: %d: %M:%M",
                     ngx_event_ident(ev->data), timer, ev->timer.key);
 
-    if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
-        return;
-    }
+    ngx_mutex_lock(ngx_event_timer_mutex);
 
     ngx_rbtree_insert(&ngx_event_timer_rbtree, &ev->timer);
 
diff --git a/src/http/modules/ngx_http_autoindex_module.c b/src/http/modules/ngx_http_autoindex_module.c
index 70f7974..3623e2a 100644
--- a/src/http/modules/ngx_http_autoindex_module.c
+++ b/src/http/modules/ngx_http_autoindex_module.c
@@ -144,6 +144,7 @@
     ngx_dir_t                       dir;
     ngx_uint_t                      i, level;
     ngx_pool_t                     *pool;
+    ngx_time_t                     *tp;
     ngx_chain_t                     out;
     ngx_array_t                     entries;
     ngx_http_autoindex_entry_t     *entry;
@@ -372,6 +373,8 @@
     b->last = ngx_cpymem(b->last, "<hr><pre><a href=\"../\">../</a>" CRLF,
                          sizeof("<hr><pre><a href=\"../\">../</a>" CRLF) - 1);
 
+    tp = ngx_timeofday();
+
     for (i = 0; i < entries.nelts; i++) {
         b->last = ngx_cpymem(b->last, "<a href=\"", sizeof("<a href=\"") - 1);
 
@@ -428,7 +431,7 @@
 
         *b->last++ = ' ';
 
-        ngx_gmtime(entry[i].mtime + ngx_gmtoff * 60 * alcf->localtime, &tm);
+        ngx_gmtime(entry[i].mtime + tp->gmtoff * 60 * alcf->localtime, &tm);
 
         b->last = ngx_sprintf(b->last, "%02d-%s-%d %02d:%02d ",
                               tm.ngx_tm_mday,
diff --git a/src/http/modules/ngx_http_geo_module.c b/src/http/modules/ngx_http_geo_module.c
index eedc1f7..6d94a06 100644
--- a/src/http/modules/ngx_http_geo_module.c
+++ b/src/http/modules/ngx_http_geo_module.c
@@ -123,6 +123,7 @@
     }
 
     tree = ngx_radix_tree_create(cf->pool, -1);
+
     if (tree == NULL) {
         return NGX_CONF_ERROR;
     }
diff --git a/src/http/modules/ngx_http_index_module.c b/src/http/modules/ngx_http_index_module.c
index 01b6d0c..b7daa6d 100644
--- a/src/http/modules/ngx_http_index_module.c
+++ b/src/http/modules/ngx_http_index_module.c
@@ -126,7 +126,8 @@
     ngx_uint_t                    i;
     ngx_http_index_t             *index;
     ngx_http_index_ctx_t         *ctx;
-    ngx_pool_cleanup_file_t      *cln;
+    ngx_pool_cleanup_t           *cln;
+    ngx_pool_cleanup_file_t      *clnf;
     ngx_http_script_code_pt       code;
     ngx_http_script_engine_t      e;
     ngx_http_core_loc_conf_t     *clcf;
@@ -180,9 +181,9 @@
             e.ip = index[i].lengths->elts;
             e.request = r;
 
-            /* 1 byte for terminating '\0' and 4 bytes is preallocation */
+            /* 1 byte for terminating '\0' */
 
-            len = 1 + 4;
+            len = 1;
 
             while (*(uintptr_t *) e.ip) {
                 lcode = *(ngx_http_script_len_code_pt *) e.ip;
@@ -190,6 +191,10 @@
             }
 
             ctx->index.len = len;
+
+            /* 16 bytes are preallocation */
+
+            len += 16;
         }
 
         if (len > ctx->path.len) {
@@ -228,6 +233,11 @@
         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
                        "open index \"%s\"", ctx->path.data);
 
+        cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_pool_cleanup_file_t));
+        if (cln == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
         fd = ngx_open_file(ctx->path.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
 
         if (fd == (ngx_fd_t) NGX_AGAIN) {
@@ -268,19 +278,12 @@
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
         }
 
+        cln->handler = ngx_pool_cleanup_file;
+        clnf = cln->data;
 
-        cln = ngx_palloc(r->pool, sizeof(ngx_pool_cleanup_file_t));
-        if (cln == NULL) {
-            return NGX_HTTP_INTERNAL_SERVER_ERROR; 
-        }
-
-        cln->fd = fd;
-        cln->name = ctx->path.data;
-        cln->log = r->pool->log;
-
-        if (ngx_pool_cleanup_add(r->pool, ngx_pool_cleanup_file, cln) == NULL) {
-            return NGX_HTTP_INTERNAL_SERVER_ERROR;
-        }
+        clnf->fd = fd;
+        clnf->name = ctx->path.data;
+        clnf->log = r->pool->log;
 
         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
 
diff --git a/src/http/modules/ngx_http_ssi_filter_module.c b/src/http/modules/ngx_http_ssi_filter_module.c
index 5f9ee3a..af82b0e 100644
--- a/src/http/modules/ngx_http_ssi_filter_module.c
+++ b/src/http/modules/ngx_http_ssi_filter_module.c
@@ -1968,6 +1968,7 @@
 {
     ngx_http_ssi_ctx_t         *ctx;
     ngx_http_variable_value_t  *vv;
+    ngx_time_t                 *tp;
     struct tm                   tm;
     char                        buf[NGX_HTTP_SSI_DATE_LEN];
 
@@ -1976,12 +1977,14 @@
         return NULL;
     }
 
+    tp = ngx_timeofday();
+
     ctx = ngx_http_get_module_ctx(r, ngx_http_ssi_filter_module);
 
     if (ctx->timefmt.len == sizeof("%s") - 1
         && ctx->timefmt.data[0] == '%' && ctx->timefmt.data[1] == 's')
     {
-        vv->value = ngx_time() + (gmt ? 0 : ngx_gmtoff);
+        vv->value = tp->sec + (gmt ? 0 : tp->gmtoff);
 
         vv->text.data = ngx_palloc(r->pool, NGX_TIME_T_LEN);
         if (vv->text.data == NULL) {
@@ -1994,12 +1997,12 @@
     }
 
     if (gmt) {
-        ngx_libc_gmtime(&tm);
+        ngx_libc_gmtime(tp->sec, &tm);
     } else {
-        ngx_libc_localtime(&tm);
+        ngx_libc_localtime(tp->sec, &tm);
     }
 
-    vv->value = ngx_time() + (gmt ? 0 : ngx_gmtoff);
+    vv->value = tp->sec + (gmt ? 0 : tp->gmtoff);
 
     vv->text.len = strftime(buf, NGX_HTTP_SSI_DATE_LEN,
                             (char *) ctx->timefmt.data, &tm);
diff --git a/src/http/modules/ngx_http_ssl_module.c b/src/http/modules/ngx_http_ssl_module.c
index bb9a55f..09bf63d 100644
--- a/src/http/modules/ngx_http_ssl_module.c
+++ b/src/http/modules/ngx_http_ssl_module.c
@@ -17,6 +17,15 @@
 static char *ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf,
     void *parent, void *child);
 
+#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
+
+static char *ngx_http_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+
+static char  ngx_http_ssl_openssl097[] = "OpenSSL 0.9.7 and higher";
+
+#endif
+
 
 static ngx_conf_bitmask_t  ngx_http_ssl_protocols[] = {
     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
@@ -26,6 +35,7 @@
 };
 
 
+
 static ngx_command_t  ngx_http_ssl_commands[] = {
 
     { ngx_string("ssl"),
@@ -50,14 +60,14 @@
       NULL },
 
     { ngx_string("ssl_protocols"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
       ngx_conf_set_bitmask_slot,
       NGX_HTTP_SRV_CONF_OFFSET,
       offsetof(ngx_http_ssl_srv_conf_t, protocols),
       &ngx_http_ssl_protocols },
 
     { ngx_string("ssl_ciphers"),
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
       ngx_conf_set_str_slot,
       NGX_HTTP_SRV_CONF_OFFSET,
       offsetof(ngx_http_ssl_srv_conf_t, ciphers),
@@ -65,10 +75,14 @@
 
     { ngx_string("ssl_prefer_server_ciphers"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
+#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
       ngx_conf_set_flag_slot,
       NGX_HTTP_SRV_CONF_OFFSET,
       offsetof(ngx_http_ssl_srv_conf_t, prefer_server_ciphers),
       NULL },
+#else
+      ngx_http_ssl_nosupported, 0, 0, ngx_http_ssl_openssl097 },
+#endif
 
       ngx_null_command
 };
@@ -144,6 +158,8 @@
     ngx_http_ssl_srv_conf_t *prev = parent;
     ngx_http_ssl_srv_conf_t *conf = child;
 
+    ngx_pool_cleanup_t  *cln;
+
     ngx_conf_merge_value(conf->enable, prev->enable, 0);
 
     if (conf->enable == 0) {
@@ -172,29 +188,37 @@
         return NGX_CONF_ERROR;
     }
 
-    if (ngx_pool_cleanup_add(cf->pool, ngx_ssl_cleanup_ctx, &conf->ssl) == NULL)
-    {
+    cln = ngx_pool_cleanup_add(cf->pool, 0);
+    if (cln == NULL) {
         return NGX_CONF_ERROR;
     }
 
-    if (ngx_ssl_certificate(&conf->ssl, conf->certificate.data,
-                            conf->certificate_key.data) != NGX_OK)
+    cln->handler = ngx_ssl_cleanup_ctx;
+    cln->data = &conf->ssl;
+
+    if (ngx_ssl_certificate(cf, &conf->ssl, &conf->certificate,
+                            &conf->certificate_key) != NGX_OK)
     {
         return NGX_CONF_ERROR;
     }
 
     if (SSL_CTX_set_cipher_list(conf->ssl.ctx,
-                                (const char *) conf->ciphers.data) == 0)
+                                (const char *) conf->ciphers.data)
+        == 0)
     {
         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
                       "SSL_CTX_set_cipher_list(\"%V\") failed",
                       &conf->ciphers);
     }
 
+#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
+
     if (conf->prefer_server_ciphers) {
         SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
     }
 
+#endif
+
     /* a temporary 512-bit RSA key is required for export versions of MSIE */
     if (ngx_ssl_generate_rsa512_key(&conf->ssl) != NGX_OK) {
         return NGX_CONF_ERROR;
@@ -207,3 +231,18 @@
 
     return NGX_CONF_OK;
 }
+
+
+#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
+
+static char *
+ngx_http_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                       "\"%V\" directive is available only in %s,",
+                       &cmd->name, cmd->post);
+
+    return NGX_CONF_ERROR;
+}
+
+#endif
diff --git a/src/http/modules/ngx_http_static_module.c b/src/http/modules/ngx_http_static_module.c
index c5d5af8..0e995f5 100644
--- a/src/http/modules/ngx_http_static_module.c
+++ b/src/http/modules/ngx_http_static_module.c
@@ -82,7 +82,8 @@
     ngx_buf_t                 *b;
     ngx_chain_t                out;
     ngx_file_info_t            fi;
-    ngx_pool_cleanup_file_t   *cln;
+    ngx_pool_cleanup_t        *cln;
+    ngx_pool_cleanup_file_t   *clnf;
     ngx_http_core_loc_conf_t  *clcf;
 
     if (r->uri.data[r->uri.len - 1] == '/') {
@@ -119,6 +120,11 @@
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
                    "http filename: \"%s\"", path.data);
 
+    cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_pool_cleanup_file_t));
+    if (cln == NULL) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
     fd = ngx_open_file(path.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
 
     if (fd == NGX_INVALID_FILE) {
@@ -223,18 +229,12 @@
 
     log->action = "sending response to client";
 
-    cln = ngx_palloc(r->pool, sizeof(ngx_pool_cleanup_file_t));
-    if (cln == NULL) {
-        return NGX_HTTP_INTERNAL_SERVER_ERROR;
-    }
+    cln->handler = ngx_pool_cleanup_file;
+    clnf = cln->data;
 
-    cln->fd = fd;
-    cln->name = path.data;
-    cln->log = r->pool->log;
-
-    if (ngx_pool_cleanup_add(r->pool, ngx_pool_cleanup_file, cln) == NULL) {
-        return NGX_HTTP_INTERNAL_SERVER_ERROR;
-    }
+    clnf->fd = fd;
+    clnf->name = path.data;
+    clnf->log = r->pool->log;
 
     r->headers_out.status = NGX_HTTP_OK;
     r->headers_out.content_length_n = ngx_file_size(&fi);
diff --git a/src/http/ngx_http.c b/src/http/ngx_http.c
index dcb3956..867bf31 100644
--- a/src/http/ngx_http.c
+++ b/src/http/ngx_http.c
@@ -659,6 +659,8 @@
 #endif
 
             ls->backlog = in_addr[a].conf.backlog;
+            ls->rcvbuf = in_addr[a].conf.rcvbuf;
+            ls->sndbuf = in_addr[a].conf.sndbuf;
 
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
             ls->accept_filter = in_addr[a].conf.accept_filter;
diff --git a/src/http/ngx_http_core_module.c b/src/http/ngx_http_core_module.c
index 4c6cfc0..21224d3 100644
--- a/src/http/ngx_http_core_module.c
+++ b/src/http/ngx_http_core_module.c
@@ -152,11 +152,7 @@
       NULL },
 
     { ngx_string("listen"),
-#if 0
-      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
-#else
       NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
-#endif
       ngx_http_core_listen,
       NGX_HTTP_SRV_CONF_OFFSET,
       0,
@@ -2010,7 +2006,7 @@
     ngx_http_core_srv_conf_t *scf = conf;
 
     char                 *err;
-    ngx_str_t            *value;
+    ngx_str_t            *value, size;
     ngx_uint_t            n;
     struct hostent       *h;
     ngx_http_listen_t    *ls;
@@ -2050,6 +2046,8 @@
     ls->file_name = cf->conf_file->file.name;
     ls->line = cf->conf_file->line;
     ls->conf.backlog = -1;
+    ls->conf.rcvbuf = -1;
+    ls->conf.sndbuf = -1;
 
     if (inet_upstream.host.len) {
         inet_upstream.host.data[inet_upstream.host.len] = '\0';
@@ -2100,8 +2098,8 @@
             continue;
         }
 
-        if (ngx_strncmp(value[n].data, "bl=", 3) == 0) {
-            ls->conf.backlog = ngx_atoi(value[n].data + 3, value[n].len - 3);
+        if (ngx_strncmp(value[n].data, "backlog=", 8) == 0) {
+            ls->conf.backlog = ngx_atoi(value[n].data + 8, value[n].len - 8);
             ls->conf.bind = 1;
 
             if (ls->conf.backlog == NGX_ERROR || ls->conf.backlog == 0) {
@@ -2113,9 +2111,41 @@
             continue;
         }
 
-        if (ngx_strncmp(value[n].data, "af=", 3) == 0) {
+        if (ngx_strncmp(value[n].data, "rcvbuf=", 7) == 0) {
+            size.len = value[n].len - 7;
+            size.data = value[n].data + 7;
+
+            ls->conf.rcvbuf = ngx_parse_size(&size);
+            ls->conf.bind = 1;
+
+            if (ls->conf.rcvbuf == NGX_ERROR) {
+                ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                                   "invalid rcvbuf \"%V\"", &value[n]);
+                return NGX_CONF_ERROR;
+            }
+
+            continue;
+        }
+
+        if (ngx_strncmp(value[n].data, "sndbuf=", 7) == 0) {
+            size.len = value[n].len - 7;
+            size.data = value[n].data + 7;
+
+            ls->conf.sndbuf = ngx_parse_size(&size);
+            ls->conf.bind = 1;
+
+            if (ls->conf.sndbuf == NGX_ERROR) {
+                ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                                   "invalid sndbuf \"%V\"", &value[n]);
+                return NGX_CONF_ERROR;
+            }
+
+            continue;
+        }
+
+        if (ngx_strncmp(value[n].data, "accept_filter=", 14) == 0) {
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
-            ls->conf.accept_filter = (char *) &value[n].data[3];
+            ls->conf.accept_filter = (char *) &value[n].data[14];
             ls->conf.bind = 1;
 #else
             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
diff --git a/src/http/ngx_http_core_module.h b/src/http/ngx_http_core_module.h
index 4de8007..cf415ef 100644
--- a/src/http/ngx_http_core_module.h
+++ b/src/http/ngx_http_core_module.h
@@ -18,6 +18,8 @@
     unsigned                   bind:1;
 
     int                        backlog;
+    int                        rcvbuf;
+    int                        sndbuf;
 
 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
     char                      *accept_filter;
diff --git a/src/http/ngx_http_log_module.c b/src/http/ngx_http_log_module.c
index 3caa2e9..617d46a 100644
--- a/src/http/ngx_http_log_module.c
+++ b/src/http/ngx_http_log_module.c
@@ -309,11 +309,11 @@
 static u_char *
 ngx_http_log_msec(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
 {
-    struct timeval  tv;
+    ngx_time_t  *tp;
 
-    ngx_gettimeofday(&tv);
+    tp = ngx_timeofday();
 
-    return ngx_sprintf(buf, "%l.%03l", tv.tv_sec, tv.tv_usec / 1000);
+    return ngx_sprintf(buf, "%T.%03M", tp->sec, tp->msec);
 }
 
 
diff --git a/src/http/ngx_http_request.c b/src/http/ngx_http_request.c
index 2fb1764..9071ae5 100644
--- a/src/http/ngx_http_request.c
+++ b/src/http/ngx_http_request.c
@@ -163,15 +163,8 @@
         /* the deferred accept(), rtsig, aio, iocp */
 
         if (ngx_accept_mutex) {
-            if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
 
-                ngx_http_close_connection(c);
-                return;
-            }
-
-            ngx_post_event(rev); 
-
-            ngx_mutex_unlock(ngx_posted_events_mutex);
+            ngx_post_event(rev, &ngx_posted_events);
 
 #if (NGX_STAT_STUB)
             ngx_atomic_fetch_add(ngx_stat_reading, 1);
diff --git a/src/http/ngx_http_upstream.c b/src/http/ngx_http_upstream.c
index a1c6a2e..6d1bd49 100644
--- a/src/http/ngx_http_upstream.c
+++ b/src/http/ngx_http_upstream.c
@@ -66,6 +66,8 @@
     uintptr_t data);
 static u_char *ngx_http_upstream_log_status(ngx_http_request_t *r,
     u_char *buf, ngx_http_log_op_t *op);
+static u_char *ngx_http_upstream_log_response_time(ngx_http_request_t *r,
+    u_char *buf, ngx_http_log_op_t *op);
 
 static u_char *ngx_http_upstream_log_error(ngx_http_request_t *r, u_char *buf,
     size_t len);
@@ -204,6 +206,8 @@
     { ngx_string("upstream_status"), 0, NULL,
                                         ngx_http_upstream_log_status_getlen,
                                         ngx_http_upstream_log_status },
+    { ngx_string("upstream_response_time"), NGX_TIME_T_LEN + 4, NULL, NULL,
+                                        ngx_http_upstream_log_response_time },
     { ngx_null_string, 0, NULL, NULL, NULL }
 };
 
@@ -217,6 +221,7 @@
 void
 ngx_http_upstream_init(ngx_http_request_t *r)
 {
+    ngx_time_t                *tp;
     ngx_connection_t          *c;
     ngx_http_upstream_t       *u;
     ngx_http_core_loc_conf_t  *clcf;
@@ -286,6 +291,10 @@
 
     ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
 
+    tp = ngx_timeofday();
+
+    u->state->response_time = tp->sec * 1000 + tp->msec;
+
     ngx_http_upstream_connect(r, u);
 }
 
@@ -978,6 +987,8 @@
     ngx_list_part_t                *part;
     ngx_table_elt_t                *h;
     ngx_event_pipe_t               *p;
+    ngx_pool_cleanup_t             *cl;
+    ngx_pool_cleanup_file_t        *clf;
     ngx_http_core_loc_conf_t       *clcf;
     ngx_http_upstream_header_t     *hh;
     ngx_http_upstream_main_conf_t  *umcf;
@@ -1033,6 +1044,20 @@
 
     u->header_sent = 1;
 
+    if (r->request_body->temp_file) {
+        for (cl = r->pool->cleanup; cl; cl = cl->next) {
+            if (cl->handler == ngx_pool_cleanup_file) {
+                clf = cl->data;
+
+                if (clf->fd == r->request_body->temp_file->file.fd) {
+                    cl->handler(clf);
+                    cl->handler = NULL;
+                    break;
+                }
+            }
+        }
+    }
+
     /* TODO: preallocate event_pipe bufs, look "Content-Length" */
 
 #if 0
@@ -1404,9 +1429,17 @@
 ngx_http_upstream_finalize_request(ngx_http_request_t *r,
     ngx_http_upstream_t *u, ngx_int_t rc)
 {
+    ngx_time_t  *tp;
+
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                    "finalize http upstream request: %i", rc);
 
+    if (u->state->response_time) {
+        tp = ngx_timeofday();
+        u->state->response_time = tp->sec * 1000 + tp->msec
+                                  - u->state->response_time;
+    }
+
     u->finalize_request(r, rc);
 
     if (u->peer.connection) {
@@ -1419,8 +1452,7 @@
 
     u->peer.connection = NULL;
 
-    if (u->header_sent
-        && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+    if (u->header_sent && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
     {
         rc = 0;
     }
@@ -1783,6 +1815,44 @@
 
 
 static u_char *
+ngx_http_upstream_log_response_time(ngx_http_request_t *r, u_char *buf,
+    ngx_http_log_op_t *op)
+{
+    ngx_uint_t                  i;
+    ngx_http_upstream_t        *u;
+    ngx_http_upstream_state_t  *state;
+
+    u = r->upstream;
+
+    if (u == NULL) {
+        *buf = '-';
+        return buf + 1;
+    }
+
+    i = 0;
+    state = u->states.elts;
+
+    for ( ;; ) {
+        if (state[i].status == 0) {
+            *buf++ = '-';
+
+        } else {
+            buf = ngx_sprintf(buf, "%d.%03d",
+                               state[i].response_time / 1000,
+                               state[i].response_time % 1000);
+        }
+
+        if (++i == u->states.nelts) {
+            return buf;
+        }
+
+        *buf++ = ',';
+        *buf++ = ' ';
+    }
+}
+
+
+static u_char *
 ngx_http_upstream_log_error(ngx_http_request_t *r, u_char *buf, size_t len)
 {
     u_char                 *p;
diff --git a/src/http/ngx_http_upstream.h b/src/http/ngx_http_upstream.h
index dd7b3c1..637a38d 100644
--- a/src/http/ngx_http_upstream.h
+++ b/src/http/ngx_http_upstream.h
@@ -29,12 +29,12 @@
 
 
 typedef struct {
-    time_t                          bl_time;
+    ngx_msec_t                      bl_time;
     ngx_uint_t                      bl_state;
 
     ngx_uint_t                      status;
-    time_t                          time;
-    
+    ngx_msec_t                      response_time;
+
     ngx_str_t                      *peer;
 } ngx_http_upstream_state_t;
 
diff --git a/src/imap/ngx_imap_core_module.c b/src/imap/ngx_imap_core_module.c
index 9d66298..d037ad8 100644
--- a/src/imap/ngx_imap_core_module.c
+++ b/src/imap/ngx_imap_core_module.c
@@ -411,6 +411,9 @@
     }
 
     ls->backlog = -1;
+    ls->rcvbuf = -1;
+    ls->sndbuf = -1;
+
     ls->addr_ntop = 1;
     ls->handler = ngx_imap_init_connection;
     ls->pool_size = 256;
diff --git a/src/imap/ngx_imap_ssl_module.c b/src/imap/ngx_imap_ssl_module.c
index be6fca9..d663e88 100644
--- a/src/imap/ngx_imap_ssl_module.c
+++ b/src/imap/ngx_imap_ssl_module.c
@@ -17,6 +17,15 @@
 static void *ngx_imap_ssl_create_conf(ngx_conf_t *cf);
 static char *ngx_imap_ssl_merge_conf(ngx_conf_t *cf, void *parent, void *child);
 
+#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
+
+static char *ngx_imap_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd,
+    void *conf);
+
+static char  ngx_imap_ssl_openssl097[] = "OpenSSL 0.9.7 and higher";
+
+#endif
+
 
 static ngx_conf_bitmask_t  ngx_imap_ssl_protocols[] = { 
     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
@@ -50,7 +59,7 @@
       NULL },
 
     { ngx_string("ssl_protocols"),
-      NGX_IMAP_MAIN_CONF|NGX_IMAP_SRV_CONF|NGX_CONF_TAKE1,
+      NGX_IMAP_MAIN_CONF|NGX_IMAP_SRV_CONF|NGX_CONF_1MORE,
       ngx_conf_set_bitmask_slot,
       NGX_IMAP_SRV_CONF_OFFSET,
       offsetof(ngx_imap_ssl_conf_t, protocols),
@@ -65,10 +74,15 @@
 
     { ngx_string("ssl_prefer_server_ciphers"),
       NGX_IMAP_MAIN_CONF|NGX_IMAP_SRV_CONF|NGX_CONF_FLAG,
+#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
       ngx_conf_set_flag_slot,
       NGX_IMAP_SRV_CONF_OFFSET,
       offsetof(ngx_imap_ssl_conf_t, prefer_server_ciphers),
       NULL },
+#else
+      ngx_imap_ssl_nosupported, 0, 0, ngx_imap_ssl_openssl097 },
+#endif
+
 
       ngx_null_command
 };
@@ -138,6 +152,8 @@
     ngx_imap_ssl_conf_t *prev = parent;
     ngx_imap_ssl_conf_t *conf = child;
 
+    ngx_pool_cleanup_t  *cln;
+
     ngx_conf_merge_value(conf->enable, prev->enable, 0);
 
     if (conf->enable == 0) {
@@ -166,20 +182,25 @@
         return NGX_CONF_ERROR;
     }
 
-    if (ngx_pool_cleanup_add(cf->pool, ngx_ssl_cleanup_ctx, &conf->ssl) == NULL)
-    {
+    cln = ngx_pool_cleanup_add(cf->pool, 0);
+    if (cln == NULL) {
         return NGX_CONF_ERROR;
     }
 
-    if (ngx_ssl_certificate(&conf->ssl, conf->certificate.data,
-                            conf->certificate_key.data) != NGX_OK)
+    cln->handler = ngx_ssl_cleanup_ctx;
+    cln->data = &conf->ssl;
+
+    if (ngx_ssl_certificate(cf, &conf->ssl, &conf->certificate,
+                            &conf->certificate_key)
+        != NGX_OK)
     {
         return NGX_CONF_ERROR;
     }
 
     if (conf->ciphers.len) {
         if (SSL_CTX_set_cipher_list(conf->ssl.ctx,
-                                   (const char *) conf->ciphers.data) == 0)
+                                   (const char *) conf->ciphers.data)
+            == 0)
         {
             ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
                           "SSL_CTX_set_cipher_list(\"%V\") failed",
@@ -187,6 +208,14 @@
         }
     }
 
+#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
+
+    if (conf->prefer_server_ciphers) {
+        SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
+    }
+
+#endif
+
     if (ngx_ssl_generate_rsa512_key(&conf->ssl) != NGX_OK) {
         return NGX_CONF_ERROR;
     }
@@ -198,3 +227,18 @@
 
     return NGX_CONF_OK;
 }
+
+    
+#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
+    
+static char *
+ngx_imap_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{   
+    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                       "\"%V\" directive is available only in %s,",
+                       &cmd->name, cmd->post);
+
+    return NGX_CONF_ERROR;
+}
+
+#endif
diff --git a/src/os/unix/ngx_atomic.h b/src/os/unix/ngx_atomic.h
index 5856103..3dfce74 100644
--- a/src/os/unix/ngx_atomic.h
+++ b/src/os/unix/ngx_atomic.h
@@ -33,6 +33,8 @@
 
 /* the code in src/os/unix/ngx_sunpro_x86.il */
 
+#define ngx_memory_barrier()        __asm (".volatile"); __asm (".nonvolatile")
+
 
 #else /* ( __GNUC__ || __INTEL_COMPILER ) */
 
@@ -64,6 +66,8 @@
 
 /* the code in src/os/unix/ngx_sunpro_amd64.il */
 
+#define ngx_memory_barrier()        __asm (".volatile"); __asm (".nonvolatile")
+
 
 #else /* ( __GNUC__ || __INTEL_COMPILER ) */
 
diff --git a/src/os/unix/ngx_channel.c b/src/os/unix/ngx_channel.c
index 051f466..c7f1293 100644
--- a/src/os/unix/ngx_channel.c
+++ b/src/os/unix/ngx_channel.c
@@ -207,6 +207,9 @@
     wev->own_lock = &c->lock;
 #endif
 
+    rev->channel = 1;
+    wev->channel = 1;
+
     ev = (event == NGX_READ_EVENT) ? rev : wev;
 
     ev->handler = handler;
diff --git a/src/os/unix/ngx_freebsd_rfork_thread.c b/src/os/unix/ngx_freebsd_rfork_thread.c
index b7e803b..3c550fb 100644
--- a/src/os/unix/ngx_freebsd_rfork_thread.c
+++ b/src/os/unix/ngx_freebsd_rfork_thread.c
@@ -51,7 +51,8 @@
 static int   errno0;   /* the main thread's errno */
 static int  *errnos;   /* the threads errno's array */
 
-int *__error()
+int *
+__error()
 {
     int  tid;
 
@@ -72,7 +73,8 @@
 
 extern int  __isthreaded;
 
-void _spinlock(ngx_atomic_t *lock)
+void
+_spinlock(ngx_atomic_t *lock)
 {
     ngx_int_t  tries;
 
@@ -107,7 +109,8 @@
 
 #ifndef _spinunlock
 
-void _spinunlock(ngx_atomic_t *lock)
+void
+_spinunlock(ngx_atomic_t *lock)
 {
     *lock = 0;
 }
@@ -115,8 +118,9 @@
 #endif
 
 
-ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
-                            ngx_log_t *log)
+ngx_err_t
+ngx_create_thread(ngx_tid_t *tid, ngx_thread_value_t (*func)(void *arg),
+    void *arg, ngx_log_t *log)
 {
     ngx_pid_t   id;
     ngx_err_t   err;
@@ -174,7 +178,8 @@
 }
 
 
-ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
+ngx_int_t
+ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
 {
     char              *red_zone, *zone;
     size_t             len;
@@ -264,7 +269,8 @@
 }
 
 
-ngx_tid_t ngx_thread_self()
+ngx_tid_t
+ngx_thread_self()
 {
     ngx_int_t  tid;
 
@@ -278,7 +284,8 @@
 }
 
 
-ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key)
+ngx_err_t
+ngx_thread_key_create(ngx_tls_key_t *key)
 {
     if (nkeys >= NGX_THREAD_KEYS_MAX) {
         return NGX_ENOMEM;
@@ -290,7 +297,8 @@
 }
 
 
-ngx_err_t ngx_thread_set_tls(ngx_tls_key_t key, void *value)
+ngx_err_t
+ngx_thread_set_tls(ngx_tls_key_t key, void *value)
 {
     if (key >= NGX_THREAD_KEYS_MAX) {
         return NGX_EINVAL;
@@ -301,7 +309,8 @@
 }
 
 
-ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
+ngx_mutex_t *
+ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
 {
     ngx_mutex_t  *m;
     union semun   op;
@@ -342,7 +351,8 @@
 }
 
 
-void ngx_mutex_destroy(ngx_mutex_t *m)
+void
+ngx_mutex_destroy(ngx_mutex_t *m)
 {
     if (semctl(m->semid, 0, IPC_RMID) == -1) {
         ngx_log_error(NGX_LOG_ALERT, m->log, ngx_errno,
@@ -353,7 +363,8 @@
 }
 
 
-ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
+ngx_int_t
+ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
 {
     uint32_t       lock, old;
     ngx_uint_t     tries;
@@ -414,7 +425,7 @@
                               "%D threads wait for mutex %p, "
                               "while only %ui threads are available",
                               lock & ~NGX_MUTEX_LOCK_BUSY, m, nthreads);
-                return NGX_ERROR;
+                ngx_abort();
             }
 
             if (ngx_atomic_cmp_set(&m->lock, old, lock)) {
@@ -436,7 +447,7 @@
                 if (semop(m->semid, &op, 1) == -1) {
                     ngx_log_error(NGX_LOG_ALERT, m->log, ngx_errno,
                                  "semop() failed while waiting on mutex %p", m);
-                    return NGX_ERROR;
+                    ngx_abort();
                 }
 
                 ngx_log_debug2(NGX_LOG_DEBUG_MUTEX, m->log, 0,
@@ -483,13 +494,14 @@
 }
 
 
-ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
+void
+ngx_mutex_unlock(ngx_mutex_t *m)
 {
     uint32_t       lock, old;
     struct sembuf  op;
 
     if (!ngx_threaded) {
-        return NGX_OK;
+        return;
     }
 
     old = m->lock;
@@ -497,7 +509,7 @@
     if (!(old & NGX_MUTEX_LOCK_BUSY)) {
         ngx_log_error(NGX_LOG_ALERT, m->log, 0,
                       "trying to unlock the free mutex %p", m);
-        return NGX_ERROR;
+        ngx_abort();
     }
 
     /* free the mutex */
@@ -521,7 +533,7 @@
         ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
                        "mutex %p is unlocked", m);
 
-        return NGX_OK;
+        return;
     }
 
     /* check whether we need to wake up a waiting thread */
@@ -558,7 +570,7 @@
             if (semop(m->semid, &op, 1) == -1) {
                 ngx_log_error(NGX_LOG_ALERT, m->log, ngx_errno,
                               "semop() failed while waking up on mutex %p", m);
-                return NGX_ERROR;
+                ngx_abort();
             }
 
             break;
@@ -570,11 +582,12 @@
     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
                    "mutex %p is unlocked", m);
 
-    return NGX_OK;
+    return;
 }
 
 
-ngx_cond_t *ngx_cond_init(ngx_log_t *log)
+ngx_cond_t *
+ngx_cond_init(ngx_log_t *log)
 {
     ngx_cond_t  *cv;
 
@@ -592,7 +605,8 @@
 }
 
 
-void ngx_cond_destroy(ngx_cond_t *cv)
+void
+ngx_cond_destroy(ngx_cond_t *cv)
 {
     if (close(cv->kq) == -1) {
         ngx_log_error(NGX_LOG_ALERT, cv->log, ngx_errno,
@@ -603,7 +617,8 @@
 }
 
 
-ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
+ngx_int_t
+ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
 {
     int              n;
     ngx_err_t        err;
@@ -647,9 +662,7 @@
         cv->tid = ngx_thread_self();
     }
 
-    if (ngx_mutex_unlock(m) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_unlock(m);
 
     ngx_log_debug3(NGX_LOG_DEBUG_CORE, cv->log, 0,
                    "cv %p wait, kq:%d, signo:%d", cv, cv->kq, cv->signo);
@@ -703,15 +716,14 @@
 
     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p is waked up", cv);
 
-    if (ngx_mutex_lock(m) == NGX_ERROR) {
-        return NGX_ERROR;
-    }
+    ngx_mutex_lock(m);
 
     return NGX_OK;
 }
 
 
-ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
+ngx_int_t
+ngx_cond_signal(ngx_cond_t *cv)
 {
     ngx_err_t  err;
 
diff --git a/src/os/unix/ngx_freebsd_rfork_thread.h b/src/os/unix/ngx_freebsd_rfork_thread.h
index 79e748a..20957a5 100644
--- a/src/os/unix/ngx_freebsd_rfork_thread.h
+++ b/src/os/unix/ngx_freebsd_rfork_thread.h
@@ -55,7 +55,8 @@
 extern size_t   ngx_thread_stack_size;
 
 
-static ngx_inline ngx_int_t ngx_gettid()
+static ngx_inline ngx_int_t
+ngx_gettid()
 {
     char  *sp;
 
@@ -97,7 +98,8 @@
 #define ngx_thread_set_tls_n     "the tls key setting"
 
 
-static void *ngx_thread_get_tls(ngx_tls_key_t key)
+static void *
+ngx_thread_get_tls(ngx_tls_key_t key)
 {   
     if (key >= NGX_THREAD_KEYS_MAX) {
         return NULL;
@@ -108,9 +110,9 @@
 
 
 #define ngx_mutex_trylock(m)  ngx_mutex_dolock(m, 1)
-#define ngx_mutex_lock(m)     ngx_mutex_dolock(m, 0)
+#define ngx_mutex_lock(m)     (void) ngx_mutex_dolock(m, 0)
 ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try);
-ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m);
+void ngx_mutex_unlock(ngx_mutex_t *m);
 
 
 typedef int (*ngx_rfork_thread_func_pt)(void *arg);
diff --git a/src/os/unix/ngx_gcc_atomic_amd64.h b/src/os/unix/ngx_gcc_atomic_amd64.h
index 07b2d50..374e3b8 100644
--- a/src/os/unix/ngx_gcc_atomic_amd64.h
+++ b/src/os/unix/ngx_gcc_atomic_amd64.h
@@ -72,3 +72,6 @@
 
     return add;
 }
+
+
+#define ngx_memory_barrier()       __asm__ volatile ("" ::: "memory")
diff --git a/src/os/unix/ngx_gcc_atomic_ppc.h b/src/os/unix/ngx_gcc_atomic_ppc.h
index 8fc3bc0..58b24c3 100644
--- a/src/os/unix/ngx_gcc_atomic_ppc.h
+++ b/src/os/unix/ngx_gcc_atomic_ppc.h
@@ -64,3 +64,10 @@
 
     return res;
 }
+
+
+#if (NGX_SMP)
+#define ngx_memory_barrier()   __asm__ volatile ("sync\n" ::: "memory")
+#else
+#define ngx_memory_barrier()   __asm__ volatile ("" ::: "memory")
+#endif
diff --git a/src/os/unix/ngx_gcc_atomic_sparc64.h b/src/os/unix/ngx_gcc_atomic_sparc64.h
index c7022a9..8314318 100644
--- a/src/os/unix/ngx_gcc_atomic_sparc64.h
+++ b/src/os/unix/ngx_gcc_atomic_sparc64.h
@@ -67,3 +67,13 @@
         old = res;
     }
 }
+
+
+#if (NGX_SMP)
+#define ngx_memory_barrier()                                                  \
+            __asm__ volatile (                                                \
+            "membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad"        \
+            ::: "memory")
+#else
+#define ngx_memory_barrier()   __asm__ volatile ("" ::: "memory")
+#endif
diff --git a/src/os/unix/ngx_gcc_atomic_x86.h b/src/os/unix/ngx_gcc_atomic_x86.h
index e3c0c93..3053e72 100644
--- a/src/os/unix/ngx_gcc_atomic_x86.h
+++ b/src/os/unix/ngx_gcc_atomic_x86.h
@@ -101,3 +101,11 @@
 }
 
 #endif
+
+
+/*
+ * on x86 the write operations go in a program order, so we need only
+ * to disable the gcc reorder optimizations
+ */
+
+#define ngx_memory_barrier()    __asm__ volatile ("" ::: "memory")
diff --git a/src/os/unix/ngx_linux_config.h b/src/os/unix/ngx_linux_config.h
index d3ef325..ac7d7a8 100644
--- a/src/os/unix/ngx_linux_config.h
+++ b/src/os/unix/ngx_linux_config.h
@@ -98,11 +98,6 @@
 #endif
 
 
-#ifndef NGX_HAVE_SELECT_CHANGE_TIMEOUT
-#define NGX_HAVE_SELECT_CHANGE_TIMEOUT   1
-#endif
-
-
 #define NGX_HAVE_OS_SPECIFIC_INIT    1
 
 
diff --git a/src/os/unix/ngx_posix_init.c b/src/os/unix/ngx_posix_init.c
index f20f44c..4a2b581 100644
--- a/src/os/unix/ngx_posix_init.c
+++ b/src/os/unix/ngx_posix_init.c
@@ -50,7 +50,7 @@
         return NGX_ERROR;
     }
     
-    ngx_max_sockets = rlmt.rlim_cur;
+    ngx_max_sockets = (ngx_int_t) rlmt.rlim_cur;
 
 #if (NGX_HAVE_INHERITED_NONBLOCK)
     ngx_inherited_nonblocking = 1;
diff --git a/src/os/unix/ngx_process.c b/src/os/unix/ngx_process.c
index 07a7c66..5e88ef3 100644
--- a/src/os/unix/ngx_process.c
+++ b/src/os/unix/ngx_process.c
@@ -282,7 +282,6 @@
 ngx_signal_handler(int signo)
 {
     char            *action;
-    struct timeval   tv;
     ngx_int_t        ignore;
     ngx_err_t        err;
     ngx_signal_t    *sig;
@@ -297,8 +296,7 @@
         }
     }
 
-    ngx_gettimeofday(&tv);
-    ngx_time_update(tv.tv_sec);
+    ngx_time_update(0, 0);
 
     action = "";
 
@@ -456,6 +454,7 @@
             if (err == NGX_ECHILD) {
                 ngx_log_error(NGX_LOG_INFO, ngx_cycle->log, errno,
                               "waitpid() failed");
+                return;
             }
 
 #endif
@@ -527,6 +526,6 @@
         break;
 
     case NGX_DEBUG_POINTS_ABORT:
-        abort();
+        ngx_abort();
     }
 }
diff --git a/src/os/unix/ngx_process_cycle.c b/src/os/unix/ngx_process_cycle.c
index 029de43..f4ec06f 100644
--- a/src/os/unix/ngx_process_cycle.c
+++ b/src/os/unix/ngx_process_cycle.c
@@ -21,7 +21,7 @@
 static void ngx_channel_handler(ngx_event_t *ev);
 #if (NGX_THREADS)
 static void ngx_wakeup_worker_threads(ngx_cycle_t *cycle);
-static void *ngx_worker_thread_cycle(void *data);
+static ngx_thread_value_t ngx_worker_thread_cycle(void *data);
 #endif
 #if 0
 static void ngx_garbage_collector_cycle(ngx_cycle_t *cycle, void *data);
@@ -69,7 +69,6 @@
     ngx_int_t          i;
     ngx_uint_t         n;
     sigset_t           set;
-    struct timeval     tv;
     struct itimerval   itv;
     ngx_uint_t         live;
     ngx_msec_t         delay;
@@ -145,8 +144,7 @@
 
         sigsuspend(&set);
 
-        ngx_gettimeofday(&tv);
-        ngx_time_update(tv.tv_sec);
+        ngx_time_update(0, 0);
 
         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "wake up");
 
@@ -275,7 +273,7 @@
     for ( ;; ) {
         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
 
-        ngx_process_events(cycle);
+        ngx_process_events_and_timers(cycle);
 
         if (ngx_terminate || ngx_quit) {
             ngx_master_exit(cycle);
@@ -645,6 +643,8 @@
 static void
 ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
 {
+    ngx_uint_t         i;
+    ngx_connection_t  *c;
 #if (NGX_THREADS)
     ngx_int_t          n;
     ngx_err_t          err;
@@ -657,11 +657,6 @@
 
 #if (NGX_THREADS)
 
-    if (ngx_time_mutex_init(cycle->log) == NGX_ERROR) {
-        /* fatal */
-        exit(2);
-    }
-
     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
 
     if (ngx_threads_n) {
@@ -731,7 +726,7 @@
 
         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
 
-        ngx_process_events(cycle);
+        ngx_process_events_and_timers(cycle);
 
         if (ngx_terminate) {
             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
@@ -740,6 +735,21 @@
             ngx_wakeup_worker_threads(cycle);
 #endif
 
+            c = cycle->connections;
+            for (i = 0; i < cycle->connection_n; i++) {
+                if (c[i].fd != -1
+                    && c[i].read
+                    && !c[i].read->accept
+                    && !c[i].read->channel)
+                {
+                    ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
+                                  "open socket #%d left in %ui connection, "
+                                  "aborting",
+                                  c[i].fd, i);
+                    ngx_abort();
+                }
+            }
+
             /*
              * we do not destroy cycle->pool here because a signal handler
              * that uses cycle->log can be called at this point
@@ -1054,7 +1064,7 @@
 }
 
 
-static void *
+static ngx_thread_value_t
 ngx_worker_thread_cycle(void *data)
 {
     ngx_thread_t  *thr = data;
@@ -1075,7 +1085,7 @@
     if (err) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
                       ngx_thread_sigmask_n " failed");
-        return (void *) 1;
+        return (ngx_thread_value_t) 1;
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
@@ -1085,25 +1095,23 @@
 
     tls = ngx_calloc(sizeof(ngx_core_tls_t), cycle->log);
     if (tls == NULL) {
-        return (void *) 1;
+        return (ngx_thread_value_t) 1;
     }
 
     err = ngx_thread_set_tls(ngx_core_tls_key, tls);
     if (err != 0) {
         ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
                       ngx_thread_set_tls_n " failed");
-        return (void *) 1;
+        return (ngx_thread_value_t) 1;
     }
 
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        return (void *) 1;
-    }
+    ngx_mutex_lock(ngx_posted_events_mutex);
 
     for ( ;; ) {
         thr->state = NGX_THREAD_FREE;
 
         if (ngx_cond_wait(thr->cv, ngx_posted_events_mutex) == NGX_ERROR) {
-            return (void *) 1;
+            return (ngx_thread_value_t) 1;
         }
 
         if (ngx_terminate) {
@@ -1115,22 +1123,22 @@
                            "thread " NGX_TID_T_FMT " is done",
                            ngx_thread_self());
 
-            return (void *) 0;
+            return (ngx_thread_value_t) 0;
         }
 
         thr->state = NGX_THREAD_BUSY;
 
         if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
-            return (void *) 1;
+            return (ngx_thread_value_t) 1;
         }
 
         if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
-            return (void *) 1;
+            return (ngx_thread_value_t) 1;
         }
 
         if (ngx_process_changes) {
             if (ngx_process_changes(cycle, 1) == NGX_ERROR) {
-                return (void *) 1;
+                return (ngx_thread_value_t) 1;
             }
         }
     }
@@ -1185,7 +1193,7 @@
 
         ngx_add_timer(ev, 60 * 60 * 1000);
 
-        ngx_process_events(cycle);
+        ngx_process_events_and_timers(cycle);
     }
 }
 
diff --git a/src/os/unix/ngx_pthread_thread.c b/src/os/unix/ngx_pthread_thread.c
index 0b55c71..c91e65d 100644
--- a/src/os/unix/ngx_pthread_thread.c
+++ b/src/os/unix/ngx_pthread_thread.c
@@ -15,8 +15,9 @@
 static pthread_attr_t  thr_attr;
 
 
-ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
-                            ngx_log_t *log)
+ngx_err_t
+ngx_create_thread(ngx_tid_t *tid, ngx_thread_value_t (*func)(void *arg),
+    void *arg, ngx_log_t *log)
 {
     int  err;
 
@@ -42,7 +43,8 @@
 }
 
 
-ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
+ngx_int_t
+ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
 {   
     int  err;
 
@@ -70,7 +72,8 @@
 }
 
 
-ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
+ngx_mutex_t *
+ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
 {
     int           err;
     ngx_mutex_t  *m;
@@ -94,7 +97,8 @@
 }
 
 
-void ngx_mutex_destroy(ngx_mutex_t *m)
+void
+ngx_mutex_destroy(ngx_mutex_t *m)
 {
     int  err;
 
@@ -109,12 +113,13 @@
 }
 
 
-ngx_int_t ngx_mutex_lock(ngx_mutex_t *m)
+void
+ngx_mutex_lock(ngx_mutex_t *m)
 {
     int  err;
 
     if (!ngx_threaded) {
-        return NGX_OK;
+        return;
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "lock mutex %p", m);
@@ -124,16 +129,17 @@
     if (err != 0) {
         ngx_log_error(NGX_LOG_ALERT, m->log, err,
                       "pthread_mutex_lock(%p) failed", m);
-        return NGX_ERROR;
+        ngx_abort();
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
 
-    return NGX_OK;
+    return;
 }
 
 
-ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m)
+ngx_int_t
+ngx_mutex_trylock(ngx_mutex_t *m)
 {
     int  err;
 
@@ -152,7 +158,7 @@
     if (err != 0) {
         ngx_log_error(NGX_LOG_ALERT, m->log, err,
                       "pthread_mutex_trylock(%p) failed", m);
-        return NGX_ERROR;
+        ngx_abort();
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
@@ -161,12 +167,13 @@
 }
 
 
-ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
+void
+ngx_mutex_unlock(ngx_mutex_t *m)
 {
     int  err;
 
     if (!ngx_threaded) {
-        return NGX_OK;
+        return;
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "unlock mutex %p", m);
@@ -176,16 +183,17 @@
     if (err != 0) {
         ngx_log_error(NGX_LOG_ALERT, m->log, err,
                       "pthread_mutex_unlock(%p) failed", m);
-        return NGX_ERROR;
+        ngx_abort();
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is unlocked", m);
 
-    return NGX_OK;
+    return;
 }
 
 
-ngx_cond_t *ngx_cond_init(ngx_log_t *log)
+ngx_cond_t *
+ngx_cond_init(ngx_log_t *log)
 {
     int          err;
     ngx_cond_t  *cv;
@@ -209,7 +217,8 @@
 }
 
 
-void ngx_cond_destroy(ngx_cond_t *cv)
+void
+ngx_cond_destroy(ngx_cond_t *cv)
 {
     int  err;
 
@@ -224,7 +233,8 @@
 }
 
 
-ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
+ngx_int_t
+ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
 {
     int  err;
 
@@ -246,7 +256,8 @@
 }
 
 
-ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
+ngx_int_t
+ngx_cond_signal(ngx_cond_t *cv)
 {
     int  err;
 
diff --git a/src/os/unix/ngx_socket.c b/src/os/unix/ngx_socket.c
index 1219589..60885dd 100644
--- a/src/os/unix/ngx_socket.c
+++ b/src/os/unix/ngx_socket.c
@@ -13,7 +13,7 @@
  * while fcntl(F_SETFL, ~O_NONBLOCK) needs to learn before
  * the previous state using fcntl(F_GETFL).
  *
- * ioctl() and fcntl() are syscalls on at least FreeBSD 2.x, Linux 2.2
+ * ioctl() and fcntl() are syscalls at least in FreeBSD 2.x, Linux 2.2
  * and Solaris 7.
  *
  * ioctl() in Linux 2.4 and 2.6 uses BKL, however, fcntl(F_SETFL) uses it too.
@@ -73,6 +73,7 @@
 
 #elif (NGX_LINUX)
 
+
 int
 ngx_tcp_nopush(ngx_socket_t s)
 {
@@ -84,6 +85,7 @@
                       (const void *) &cork, sizeof(int));
 }
 
+
 int
 ngx_tcp_push(ngx_socket_t s)
 {
@@ -103,6 +105,7 @@
     return 0;
 }
 
+
 int
 ngx_tcp_push(ngx_socket_t s)
 {
diff --git a/src/os/unix/ngx_sunpro_atomic_sparc64.h b/src/os/unix/ngx_sunpro_atomic_sparc64.h
index e634416..6b4ce84 100644
--- a/src/os/unix/ngx_sunpro_atomic_sparc64.h
+++ b/src/os/unix/ngx_sunpro_atomic_sparc64.h
@@ -50,3 +50,9 @@
         old = res;
     }
 }
+
+
+#define ngx_memory_barrier()                                                  \
+        __asm (".volatile");                                                  \
+        __asm ("membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad");   \
+        __asm (".nonvolatile")
diff --git a/src/os/unix/ngx_thread.h b/src/os/unix/ngx_thread.h
index e630b35..5171be6 100644
--- a/src/os/unix/ngx_thread.h
+++ b/src/os/unix/ngx_thread.h
@@ -66,8 +66,8 @@
 
 
 ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m);
-ngx_int_t ngx_mutex_lock(ngx_mutex_t *m);
-ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m);
+void ngx_mutex_lock(ngx_mutex_t *m);
+void ngx_mutex_unlock(ngx_mutex_t *m);
 
 #endif
 
@@ -90,10 +90,11 @@
 extern volatile ngx_thread_t  ngx_threads[NGX_MAX_THREADS];
 
 
-ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle);
-ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
-                            ngx_log_t *log);
+typedef void *  ngx_thread_value_t;
 
+ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle);
+ngx_err_t ngx_create_thread(ngx_tid_t *tid,
+    ngx_thread_value_t (*func)(void *arg), void *arg, ngx_log_t *log);
 
 ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags);
 void ngx_mutex_destroy(ngx_mutex_t *m);
@@ -113,7 +114,7 @@
 #define NGX_TID_T_FMT         "%d"
 
 #define ngx_mutex_trylock(m)  NGX_OK
-#define ngx_mutex_lock(m)     NGX_OK
+#define ngx_mutex_lock(m)
 #define ngx_mutex_unlock(m)
 
 #define ngx_cond_signal(cv)
diff --git a/src/os/unix/ngx_time.c b/src/os/unix/ngx_time.c
index 1b1a566..927132d 100644
--- a/src/os/unix/ngx_time.c
+++ b/src/os/unix/ngx_time.c
@@ -8,20 +8,16 @@
 #include <ngx_core.h>
 
 
-void ngx_localtime(ngx_tm_t *tm)
+void
+ngx_localtime(time_t s, ngx_tm_t *tm)
 {
 #if (NGX_HAVE_LOCALTIME_R)
-    time_t     now;
-
-    now = ngx_time();
-    (void) localtime_r(&now, tm);
+    (void) localtime_r(&s, tm);
 
 #else
-    time_t     now;
     ngx_tm_t  *t;
 
-    now = ngx_time();
-    t = localtime(&now);
+    t = localtime(&s);
     *tm = *t;
 
 #endif
@@ -31,40 +27,32 @@
 }
 
 
-void ngx_libc_localtime(struct tm *tm)
+void
+ngx_libc_localtime(time_t s, struct tm *tm)
 {
 #if (NGX_HAVE_LOCALTIME_R)
-    time_t      now;
-
-    now = ngx_time();
-    (void) localtime_r(&now, tm);
+    (void) localtime_r(&s, tm);
 
 #else
-    time_t      now;
     struct tm  *t;
 
-    now = ngx_time();
-    t = localtime(&now);
+    t = localtime(&s);
     *tm = *t;
 
 #endif
 }
 
 
-void ngx_libc_gmtime(struct tm *tm)
+void
+ngx_libc_gmtime(time_t s, struct tm *tm)
 {
 #if (NGX_HAVE_LOCALTIME_R)
-    time_t      now;
-
-    now = ngx_time();
-    (void) gmtime_r(&now, tm);
+    (void) gmtime_r(&s, tm);
 
 #else
-    time_t      now;
     struct tm  *t;
 
-    now = ngx_time();
-    t = gmtime(&now);
+    t = gmtime(&s);
     *tm = *t;
 
 #endif
diff --git a/src/os/unix/ngx_time.h b/src/os/unix/ngx_time.h
index f9fe3c5..b31bd47 100644
--- a/src/os/unix/ngx_time.h
+++ b/src/os/unix/ngx_time.h
@@ -52,9 +52,9 @@
 #endif
 
 
-void ngx_localtime(ngx_tm_t *tm);
-void ngx_libc_localtime(struct tm *tm);
-void ngx_libc_gmtime(struct tm *tm);
+void ngx_localtime(time_t s, ngx_tm_t *tm);
+void ngx_libc_localtime(time_t s, struct tm *tm);
+void ngx_libc_gmtime(time_t s, struct tm *tm);
 
 #define ngx_gettimeofday(tp)  (void) gettimeofday(tp, NULL);
 #define ngx_msleep(ms)        (void) usleep(ms * 1000)
diff --git a/src/os/win32/ngx_atomic.h b/src/os/win32/ngx_atomic.h
index 87de57d..1e33345 100644
--- a/src/os/win32/ngx_atomic.h
+++ b/src/os/win32/ngx_atomic.h
@@ -41,6 +41,9 @@
 #define ngx_atomic_fetch_add(p, add) InterlockedExchangeAdd((long *) p, add)
 
 
+#define ngx_memory_barrier()
+
+
 void ngx_spinlock(ngx_atomic_t *lock, ngx_uint_t spin);
 
 #define ngx_trylock(lock)  (*(lock) == 0 && ngx_atomic_cmp_set(lock, 0, 1))
diff --git a/src/os/win32/ngx_process_cycle.c b/src/os/win32/ngx_process_cycle.c
index 7eabefe..be363e2 100644
--- a/src/os/win32/ngx_process_cycle.c
+++ b/src/os/win32/ngx_process_cycle.c
@@ -10,7 +10,7 @@
 #include <nginx.h>
 
 
-static void *ngx_worker_thread_cycle(void *data);
+static ngx_thread_value_t __stdcall ngx_worker_thread_cycle(void *data);
 static long __stdcall ngx_window_procedure(HWND window, u_int message,
     u_int wparam, long lparam);
 
@@ -202,7 +202,7 @@
 }
 
 
-static void *
+static ngx_thread_value_t __stdcall
 ngx_worker_thread_cycle(void *data)
 {
     ngx_cycle_t  *cycle;
@@ -212,10 +212,10 @@
     while (!ngx_quit) {
         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
 
-        ngx_process_events(cycle);
+        ngx_process_events_and_timers(cycle);
     }
 
-    return NULL;
+    return 0;
 }
 
 
diff --git a/src/os/win32/ngx_thread.c b/src/os/win32/ngx_thread.c
index 0703ac7..f8cedd2 100644
--- a/src/os/win32/ngx_thread.c
+++ b/src/os/win32/ngx_thread.c
@@ -14,13 +14,13 @@
 static size_t  stack_size;
 
 
-ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
-                      ngx_log_t *log)
+ngx_err_t
+ngx_create_thread(ngx_tid_t *tid,
+    ngx_thread_value_t (__stdcall *func)(void *arg), void *arg, ngx_log_t *log)
 {
     ngx_err_t  err;
 
-    *tid = CreateThread(NULL, stack_size,
-                        (LPTHREAD_START_ROUTINE) func, arg, 0, NULL);
+    *tid = CreateThread(NULL, stack_size, func, arg, 0, NULL);
 
     if (*tid != NULL) {
         return 0;
@@ -32,7 +32,8 @@
 }
 
 
-ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
+ngx_int_t
+ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
 {
     stack_size = size;
 
@@ -40,7 +41,8 @@
 }
 
 
-ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key)
+ngx_err_t
+ngx_thread_key_create(ngx_tls_key_t *key)
 {
     *key = TlsAlloc();
 
@@ -52,7 +54,8 @@
 }
 
 
-ngx_err_t ngx_thread_set_tls(ngx_tls_key_t *key, void *data)
+ngx_err_t
+ngx_thread_set_tls(ngx_tls_key_t *key, void *data)
 {
     if (TlsSetValue(*key, data) == 0) {
         return ngx_errno;
@@ -62,7 +65,8 @@
 }
 
 
-ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
+ngx_mutex_t *
+ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
 {
     return (ngx_mutex_t *) 1;
 }
@@ -70,15 +74,22 @@
 
 /* STUB */
 
-ngx_int_t
+void
 ngx_mutex_lock(ngx_mutex_t *m) {
-    return NGX_OK;
+    return;
 }
 
 
+
 ngx_int_t
 ngx_mutex_trylock(ngx_mutex_t *m) {
     return NGX_OK;
 }
 
+
+void
+ngx_mutex_unlock(ngx_mutex_t *m) {
+    return;
+}
+
 /**/
diff --git a/src/os/win32/ngx_thread.h b/src/os/win32/ngx_thread.h
index b55dcca..3da1dc2 100644
--- a/src/os/win32/ngx_thread.h
+++ b/src/os/win32/ngx_thread.h
@@ -14,6 +14,7 @@
 
 typedef HANDLE  ngx_tid_t;
 typedef DWORD   ngx_tls_key_t;
+typedef DWORD   ngx_thread_value_t;
 
 
 typedef struct {
@@ -22,8 +23,8 @@
 } ngx_mutex_t;
 
 
-ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg),
-    void *arg, ngx_log_t *log);
+ngx_err_t ngx_create_thread(ngx_tid_t *tid,
+    ngx_thread_value_t (__stdcall *func)(void *arg), void *arg, ngx_log_t *log);
 ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle);
 
 ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key);
@@ -41,14 +42,13 @@
 
 ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags);
 
-ngx_int_t ngx_mutex_lock(ngx_mutex_t *m);
+void ngx_mutex_lock(ngx_mutex_t *m);
 ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m);
+void ngx_mutex_unlock(ngx_mutex_t *m);
 
 
 /* STUB */
 #define NGX_MUTEX_LIGHT             0
-
-#define ngx_mutex_unlock(m)
 /**/
 
 
diff --git a/src/os/win32/ngx_time.c b/src/os/win32/ngx_time.c
index 04a1af6..39ce633 100644
--- a/src/os/win32/ngx_time.c
+++ b/src/os/win32/ngx_time.c
@@ -8,7 +8,8 @@
 #include <ngx_core.h>
 
 
-void ngx_gettimeofday(struct timeval *tp)
+void
+ngx_gettimeofday(struct timeval *tp)
 {
     uint64_t  intervals;
     FILETIME  ft;
@@ -36,29 +37,28 @@
 }
 
 
-void ngx_libc_localtime(struct tm *tm)
+void
+ngx_libc_localtime(time_t s, struct tm *tm)
 {
-    time_t      now;
     struct tm  *t;
 
-    now = ngx_time();
-    t = localtime(&now);
+    t = localtime(&s);
     *tm = *t;
 }
 
 
-void ngx_libc_gmtime(struct tm *tm)
+void
+ngx_libc_gmtime(time_t s, struct tm *tm)
 {
-    time_t      now;
     struct tm  *t;
 
-    now = ngx_time();
-    t = gmtime(&now);
+    t = gmtime(&s);
     *tm = *t;
 }
 
 
-ngx_int_t ngx_gettimezone(void)
+ngx_int_t
+ngx_gettimezone(void)
 {
     TIME_ZONE_INFORMATION  tz;
 
diff --git a/src/os/win32/ngx_time.h b/src/os/win32/ngx_time.h
index 4c14984..225c38c 100644
--- a/src/os/win32/ngx_time.h
+++ b/src/os/win32/ngx_time.h
@@ -40,8 +40,8 @@
 #define NGX_HAVE_GETTIMEZONE  1
 
 ngx_int_t ngx_gettimezone(void);
-void ngx_libc_localtime(struct tm *tm);
-void ngx_libc_gmtime(struct tm *tm);
+void ngx_libc_localtime(time_t s, struct tm *tm);
+void ngx_libc_gmtime(time_t s, struct tm *tm);
 void ngx_gettimeofday(struct timeval *tp);
 
 
diff --git a/src/os/win32/ngx_win32_config.h b/src/os/win32/ngx_win32_config.h
index a814acb..9658c12 100644
--- a/src/os/win32/ngx_win32_config.h
+++ b/src/os/win32/ngx_win32_config.h
@@ -8,6 +8,10 @@
 #define _NGX_WIN32_CONFIG_H_INCLUDED_
 
 
+#define WIN32         0x0400
+#define _WIN32_WINNT  0x0400
+
+
 #define STRICT
 #define WIN32_LEAN_AND_MEAN