Mercurial > hg > nginx

changeset 39:83fa61cd3d2f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.1-2002-12-24-20:30:59 import
author Igor Sysoev <igor@sysoev.ru>
date Tue, 24 Dec 2002 17:30:59 +0000
parents 2ffaa35fba42
children d5d4f3bba6f0
files src/core/nginx.c src/core/ngx_alloc.c src/core/ngx_config.h src/core/ngx_config_file.h src/event/modules/ngx_devpoll_module.c src/event/modules/ngx_devpoll_module.h src/event/modules/ngx_kqueue_module.c src/event/modules/ngx_poll_module.c src/event/modules/ngx_select_module.c src/event/ngx_event.c src/event/ngx_event.h src/http/ngx_http.c src/http/ngx_http_core.c src/http/ngx_http_event.c
diffstat 14 files changed, 465 insertions(+), 272 deletions(-) [+]
line wrap: on
line diff
--- a/src/core/nginx.c
+++ b/src/core/nginx.c
@@ -56,7 +56,7 @@ int main(int argc, char *const *argv)
 
     /* TODO: read config */
 
-#if 1
+#if 0
     ngx_memzero(&conf, sizeof(ngx_conf_t));
     ngx_test_null(conf.args,
                   ngx_create_array(ngx_pool, 10, sizeof(ngx_str_t)), 1);
--- a/src/core/ngx_alloc.c
+++ b/src/core/ngx_alloc.c
@@ -12,11 +12,14 @@ void *ngx_alloc(size_t size, ngx_log_t *
     void *p;
 
     p = malloc(size);
-    if (p == NULL)
+    if (p == NULL) {
         ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                       "malloc() %d bytes failed", size);
+    }
 
+#if (NGX_DEBUG_ALLOC)
     ngx_log_debug(log, "malloc: %08x:%d" _ p _ size);
+#endif
 
     return p;
 }
@@ -26,8 +29,9 @@ void *ngx_calloc(size_t size, ngx_log_t 
     void *p;
 
     p = ngx_alloc(size, log);
-    if (p)
+    if (p) {
         ngx_memzero(p, size);
+    }
 
     return p;
 }
@@ -53,16 +57,21 @@ void ngx_destroy_pool(ngx_pool_t *pool)
     ngx_pool_large_t  *l;
 
     for (l = pool->large; l; l = l->next) {
+#if (NGX_DEBUG_ALLOC)
         ngx_log_debug(pool->log, "free: %08x" _ l->alloc);
+#endif
         free(l->alloc);
     }
 
     for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
+#if (NGX_DEBUG_ALLOC)
         ngx_log_debug(pool->log, "free: %08x" _ p);
+#endif
         free(p);
 
-        if (n == NULL)
+        if (n == NULL) {
             break;
+        }
     }
 }
 
@@ -83,8 +92,9 @@ void *ngx_palloc(ngx_pool_t *pool, size_
                 return m;
             }
 
-            if (n == NULL)
+            if (n == NULL) {
                 break;
+            }
         }
 
         /* alloc new pool block */
@@ -107,8 +117,9 @@ void *ngx_palloc(ngx_pool_t *pool, size_
                     break;
                 }
 
-                if (last->next == NULL)
+                if (last->next == NULL) {
                     break;
+                }
             }
         }
 
@@ -138,8 +149,9 @@ void *ngx_pcalloc(ngx_pool_t *pool, size
     void *p;
 
     p = ngx_palloc(pool, size);
-    if (p)
+    if (p) {
         ngx_memzero(p, size);
+    }
 
     return p;
 }
--- a/src/core/ngx_config.h
+++ b/src/core/ngx_config.h
@@ -99,6 +99,12 @@
 */
 #endif
 
+
+#if (HAVE_DEVPOLL)
+#include <sys/devpoll.h>        /* Solaris, HP/UX */
+#endif
+
+
 #define ngx_inline   inline
 
 
--- a/src/core/ngx_config_file.h
+++ b/src/core/ngx_config_file.h
@@ -53,6 +53,10 @@ typedef struct {
     char    *description;
 } ngx_command_t;
 
+
+int ngx_conf_read_token(ngx_conf_t *cf);
+
+
 char *ngx_conf_set_size_slot(char *conf, int offset, char *value);
 char *ngx_conf_set_time_slot(char *conf, int offset, char *value);
 
--- a/src/event/modules/ngx_devpoll_module.c
+++ b/src/event/modules/ngx_devpoll_module.c
@@ -16,10 +16,17 @@
 #endif
 
 
+/* STUB */
+#define DEVPOLL_NCHANGES  512
+#define DEVPOLL_NEVENTS   512
+
 /* should be per-thread */
 static int              dp;
 static struct pollfd   *change_list, *event_list;
-static int              nchanges, nevents;
+static unsigned int     nchanges;
+static int              nevents;
+
+static ngx_event_t    **change_index;
 
 static ngx_event_t      timer_queue;
 /* */
@@ -27,11 +34,12 @@ static ngx_event_t      timer_queue;
 
 int ngx_devpoll_init(int max_connections, ngx_log_t *log)
 {
-    int size;
+    int  change_size, event_size;
 
-    size = sizeof(struct pollfd) * 512;
+    nevents = DEVPOLL_NEVENTS;
     nchanges = 0;
-    nevents = 512;
+    change_size = sizeof(struct pollfd) * DEVPOLL_NCHANGES;
+    event_size = sizeof(struct pollfd) * DEVPOLL_NEVENTS;
 
     dp = open("/dev/poll", O_RDWR);
 
@@ -40,9 +48,10 @@ int ngx_devpoll_init(int max_connections
         return NGX_ERROR;
     }
 
-    ngx_test_null(change_list, ngx_alloc(size, log), NGX_ERROR);
-    ngx_test_null(event_list, ngx_alloc(size, log), NGX_ERROR);
-    ngx_test_null(event_index, ngx_alloc(sizeof(ngx_event_t *) * nevents, log),
+    ngx_test_null(change_list, ngx_alloc(change_size, log), NGX_ERROR);
+    ngx_test_null(event_list, ngx_alloc(event_size, log), NGX_ERROR);
+    ngx_test_null(change_index,
+                  ngx_alloc(sizeof(ngx_event_t *) * DEVPOLL_NCHANGES, log),
                   NGX_ERROR);
 
     timer_queue.timer_prev = &timer_queue;
@@ -59,95 +68,89 @@ int ngx_devpoll_init(int max_connections
 }
 
 
-/* NOT READY */
-
 int ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_event_t      *e;
-    ngx_connection_t *c;
+#if (NGX_DEBUG_EVENT)
+    ngx_connection_t *c = (ngx_connection_t *) ev->data;
+#endif
+
+#if (NGX_READ_EVENT != POLLIN)
+    if (event == NGX_READ_EVENT) {
+        event = POLLOUT;
+#if (NGX_WRITE_EVENT != POLLOUT)
+    } else {
+        event = POLLIN;
+#endif
+    }
+#endif
+
+#if (NGX_DEBUG_EVENT)
+    c = (ngx_connection_t *) ev->data;
+    ngx_log_debug(ev->log, "add event: %d:%d" _ c->fd _ event);
+#endif
+
+    ev->active = 1;
+    ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
 
-    c = (ngx_connection_t *) ev->data;
+    return ngx_devpoll_set_event(ev, event, 0);
+}
+
+
+int ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags)
+{
+    ngx_event_t  *e;
 
-    ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
+#if (NGX_DEBUG_EVENT)
+    ngx_connection_t *c = (ngx_connection_t *) ev->data;
+    ngx_log_debug(c->log, "del event: %d, %d" _ c->fd _ event);
+#endif
+
+    if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    ev->active = 0;
+
+    if (flags & NGX_CLOSE_EVENT) {
+        return NGX_OK;
+    }
 
     if (event == NGX_READ_EVENT) {
         e = c->write;
-#if (NGX_READ_EVENT != POLLIN)
-        event = POLLIN;
-#endif
+        event = POLLOUT;
 
     } else {
         e = c->read;
-#if (NGX_WRITE_EVENT != POLLOUT)
-        event = POLLOUT;
-#endif
+        event = POLLIN;
     }
 
-    ngx_log_debug(ev->log, "poll fd:%d event:%d" _ c->fd _ event);
-
-    if (e == NULL || e->index == NGX_INVALID_INDEX) {
-        event_list[nevents].fd = c->fd;
-        event_list[nevents].events = event;
-        event_list[nevents].revents = 0;
-
-        event_index[nevents] = ev;
-        ev->index = nevents;
-        nevents++;
-
-    } else {
-        event_list[e->index].events |= event;
-        ev->index = e->index;
+    if (e) {
+        return ngx_devpoll_set_event(e, event, 0);
     }
 
-    return ngx_devpoll_set_event(ev, event, EV_ADD | flags);
+    return NGX_OK;
 }
 
-/* NOT READY */
 
-int ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags)
-{
-    ngx_event_t *e;
-
-    if (nchanges > 0 && ev->index < nchanges
-        && change_list[ev->index].udata == ev)
-    {
-        ngx_connection_t *cn = (ngx_connection_t *) ev->data;
-        ngx_log_debug(ev->log, "kqueue del event: %d: ft:%d" _
-                      cn->fd _ event);
-
-        if (ev->index < --nchanges) {
-            e = (ngx_event_t *) change_list[nchanges].udata;
-            change_list[ev->index] = change_list[nchanges];
-            e->index = ev->index;
-        }
-
-        return NGX_OK;
-    }
-
-    if (flags & NGX_CLOSE_EVENT)
-        return NGX_OK;
-
-    return ngx_devpoll_set_event(ev, POLLREMOVE);
-}
-
-/* NOT READY */
-
-int ngx_devpoll_set_event(ngx_event_t *ev, int event)
+int ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags)
 {
     int  n;
-    ngx_connection_t *c;
+    ngx_connection_t  *c;
 
     c = (ngx_connection_t *) ev->data;
 
-    ngx_log_debug(ev->log, "devpoll fd:%d event:%d" _ c->fd _ event);
+#if (NGX_DEBUG_EVENT)
+    ngx_log_debug(ev->log, "devpoll fd:%d event:%d flush:%d" _
+                           c->fd _ event _ flags);
+#endif
 
-    if (nchanges >= nevents) {
+    if (nchanges >= DEVPOLL_NCHANGES) {
         ngx_log_error(NGX_LOG_WARN, ev->log, 0,
                       "/dev/pool change list is filled up");
 
         n = nchanges * sizeof(struct pollfd);
         if (write(dp, change_list, n) != n) {
-            ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
+            ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
                           "write(/dev/poll) failed");
             return NGX_ERROR;
         }
@@ -155,19 +158,25 @@ int ngx_devpoll_set_event(ngx_event_t *e
         nchanges = 0;
     }
 
-    event_list[nchanges].fd = c->fd;
-    event_list[nchanges].events = event;
-    event_list[nchanges].revents = 0;
+    change_list[nchanges].fd = c->fd;
+    change_list[nchanges].events = event;
+    change_list[nchanges].revents = 0;
 
-    event_index[nchanges] = ev;
+    change_index[nchanges] = ev;
     ev->index = nchanges;
 
-/*
-    if (flags == EV_ADD)
-        ev->index = nchanges;
-*/
+    nchanges++;
 
-    nchanges++;
+    if (flags & NGX_CLOSE_EVENT) {
+        n = nchanges * sizeof(struct pollfd);
+        if (write(dp, change_list, n) != n) {
+            ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
+                          "write(/dev/poll) failed");
+            return NGX_ERROR;
+        }
+
+        nchanges = 0;
+    }
 
     return NGX_OK;
 }
@@ -175,27 +184,27 @@ int ngx_devpoll_set_event(ngx_event_t *e
 
 int ngx_devpoll_process_events(ngx_log_t *log)
 {
-    int              events, i;
-    u_int            timer, delta;
-    ngx_event_t      *ev;
-    struct dvpoll    dvpoll;
-    struct timeval   tv;
+    int                events, n, i;
+    u_int              timer, delta;
+    ngx_err_t          err;
+    ngx_event_t       *ev;
+    ngx_connection_t  *c;
+    struct dvpoll      dvpoll;
+    struct timeval     tv;
 
     if (timer_queue.timer_next != &timer_queue) {
         timer = timer_queue.timer_next->timer_delta;
-#if 1
         gettimeofday(&tv, NULL);
         delta = tv.tv_sec * 1000 + tv.tv_usec / 1000;
-#else
-        delta = ngx_msec();
-#endif
 
     } else {
         timer = INFTIM;
         delta = 0;
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(log, "devpoll timer: %d" _ timer);
+#endif
 
     n = nchanges * sizeof(struct pollfd);
     if (write(dp, change_list, n) != n) {
@@ -216,53 +225,41 @@ int ngx_devpoll_process_events(ngx_log_t
     nchanges = 0;
 
     if (timer != INFTIM) {
-#if 1
         gettimeofday(&tv, NULL);
         delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
-#else
-        delta = ngx_msec() - delta;
-#endif
 
     } else {
-        ngx_assert((events != 0), return NGX_ERROR, log,
-                   "ioctl(DP_POLL) returns no events without timeout");
-    }
-
-    ngx_log_debug(log, "devpoll timer: %d, delta: %d" _ timer _ delta);
-
-    if (timer != INFTIM) {
-        if (delta >= timer) {
-            for ( ;; ) {
-                ev = timer_queue.timer_next;
-
-                if (ev == &timer_queue || delta < ev->timer_delta)
-                    break;
-
-                delta -= ev->timer_delta;
-                ngx_del_timer(ev);
-                ev->timedout = 1;
-                if (ev->event_handler(ev) == NGX_ERROR)
-                    ev->close_handler(ev);
-            }
-
-        } else {
-           timer_queue.timer_next->timer_delta -= delta;
+        if (events == 0) {
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "ioctl(DP_POLL) returns no events without timeout");
+            return NGX_ERROR;
         }
     }
 
+#if (NGX_DEBUG_EVENT)
+    ngx_log_debug(log, "devpoll timer: %d, delta: %d" _ timer _ delta);
+#endif
+
     for (i = 0; i < events; i++) {
 
+#if (NGX_DEBUG_EVENT)
         ngx_log_debug(log, "devpoll: %d: ev:%d rev:%d" _
                       event_list[i].fd _
                       event_list[i].events _ event_list[i].revents);
+#endif
 
+        c = &ngx_connections[event_list[i].fd];
 
         if (event_list[i].revents & POLLIN) {
+            if (!c->read->active) {
+                continue;
+            }
+
             c->read->ready = 1;
-            
+
             if (c->read->oneshot) {
                 ngx_del_timer(c->read);
-                ngx_select_del_event(c->read, NGX_READ_EVENT, 0);
+                ngx_devpoll_del_event(c->read, NGX_READ_EVENT, 0);
             }
 
             if (c->read->event_handler(c->read) == NGX_ERROR) {
@@ -271,11 +268,15 @@ int ngx_devpoll_process_events(ngx_log_t
         }
 
         if (event_list[i].revents & POLLOUT) {
+            if (!c->write->active) {
+                continue;
+            }
+
             c->write->ready = 1;
 
             if (c->write->oneshot) {
                 ngx_del_timer(c->write);
-                ngx_select_del_event(c->write, NGX_WRITE_EVENT, 0);
+                ngx_devpoll_del_event(c->write, NGX_WRITE_EVENT, 0);
             }
 
             if (c->write->event_handler(c->write) == NGX_ERROR) {
@@ -284,12 +285,40 @@ int ngx_devpoll_process_events(ngx_log_t
         }
 
         if (event_list[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
-            ngx_log_error(NGX_LOG_ERR, log, ngx_errno,
+            err = 0;
+            if (event_list[i].revents & POLLNVAL) {
+                err = EBADF;
+            }
+
+            ngx_log_error(NGX_LOG_ERR, log, err,
                           "ioctl(DP_POLL) error on %d:%d",
                           event_list[i].fd, event_list[i].revents);
         }
     }
 
+    if (timer != INFTIM && timer_queue.timer_next != &timer_queue) {
+        if (delta >= timer_queue.timer_next->timer_delta) {
+            for ( ;; ) {
+                ev = timer_queue.timer_next;
+
+                if (ev == &timer_queue || delta < ev->timer_delta) {
+                    break;
+                }
+
+                delta -= ev->timer_delta;
+
+                ngx_del_timer(ev);
+                ev->timedout = 1;
+                if (ev->event_handler(ev) == NGX_ERROR) {
+                    ev->close_handler(ev);
+                }
+            }
+
+        } else {
+           timer_queue.timer_next->timer_delta -= delta;
+        }
+    }
+
     return NGX_OK;
 }
 
@@ -298,15 +327,22 @@ void ngx_devpoll_add_timer(ngx_event_t *
 {
     ngx_event_t *e;
 
-    ngx_log_debug(ev->log, "set timer: %d" _ timer);
+#if (NGX_DEBUG_EVENT)
+    ngx_connection_t *c = (ngx_connection_t *) ev->data;
+    ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
+#endif
 
-    ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
-               "timer already set");
+    if (ev->timer_next || ev->timer_prev) {
+        ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
+        return;
+    }
 
     for (e = timer_queue.timer_next;
          e != &timer_queue && timer > e->timer_delta;
          e = e->timer_next)
+    {
         timer -= e->timer_delta;
+    }
 
     ev->timer_delta = timer;
 
--- a/src/event/modules/ngx_devpoll_module.h
+++ b/src/event/modules/ngx_devpoll_module.h
@@ -13,9 +13,18 @@ void ngx_devpoll_add_timer(ngx_event_t *
 int ngx_devpoll_process_events(ngx_log_t *log);
 
 
+#if 0
 /* DEBUG */
 #define POLLREMOVE   0x0800
-#define DP_POLL      1
+#define DP_POLL      0xD001
+
+struct dvpoll {
+    struct pollfd* dp_fds;
+    int dp_nfds;
+    int dp_timeout;
+};
+
+#endif
 
 
 #endif /* _NGX_DEVPOLL_MODULE_H_INCLUDED_ */
--- a/src/event/modules/ngx_kqueue_module.c
+++ b/src/event/modules/ngx_kqueue_module.c
@@ -16,10 +16,16 @@
 #endif
 
 
+/* STUB */
+#define KQUEUE_NCHANGES  512
+#define KQUEUE_NEVENTS   512
+
+
 /* should be per-thread */
 static int              kq;
 static struct kevent   *change_list, *event_list;
-static int              nchanges, nevents;
+static unsigned int     nchanges;
+static int              nevents;
 
 static ngx_event_t      timer_queue;
 /* */
@@ -27,11 +33,12 @@ static ngx_event_t      timer_queue;
 
 int ngx_kqueue_init(int max_connections, ngx_log_t *log)
 {
-    int size;
+    int  change_size, event_size;
 
-    size = sizeof(struct kevent) * 512;
+    nevents = KQUEUE_NEVENTS;
     nchanges = 0;
-    nevents = 512;
+    change_size = sizeof(struct kevent) * KQUEUE_NCHANGES;
+    event_size = sizeof(struct kevent) * KQUEUE_NEVENTS;
 
     kq = kqueue();
 
@@ -40,8 +47,8 @@ int ngx_kqueue_init(int max_connections,
         return NGX_ERROR;
     }
 
-    ngx_test_null(change_list, ngx_alloc(size, log), NGX_ERROR);
-    ngx_test_null(event_list, ngx_alloc(size, log), NGX_ERROR);
+    ngx_test_null(change_list, ngx_alloc(change_size, log), NGX_ERROR);
+    ngx_test_null(event_list, ngx_alloc(event_size, log), NGX_ERROR);
 
     timer_queue.timer_prev = &timer_queue;
     timer_queue.timer_next = &timer_queue;
@@ -59,16 +66,17 @@ int ngx_kqueue_init(int max_connections,
 
 int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
 {
+    ev->active = 1;
     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
 
     if (nchanges > 0
         && ev->index < nchanges
         && change_list[ev->index].udata == ev)
     {
-        /* DEBUG */
+#if (NGX_DEBUG_EVENT)
         ngx_connection_t *c = (ngx_connection_t *) ev->data;
         ngx_log_debug(ev->log, "kqueue add event: %d: ft:%d" _ c->fd _ event);
-
+#endif
         change_list[ev->index].filter = event;
         change_list[ev->index].flags = flags;
 
@@ -81,16 +89,18 @@ int ngx_kqueue_add_event(ngx_event_t *ev
 
 int ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_event_t *e;
+    ngx_event_t  *e;
+
+    ev->active = 0;
 
     if (nchanges > 0
         && ev->index < nchanges
         && change_list[ev->index].udata == ev)
     {
-        /* DEBUG */
+#if (NGX_DEBUG_EVENT)
         ngx_connection_t *c = (ngx_connection_t *) ev->data;
         ngx_log_debug(ev->log, "kqueue del event: %d: ft:%d" _ c->fd _ event);
-
+#endif
         if (ev->index < --nchanges) {
             e = (ngx_event_t *) change_list[nchanges].udata;
             change_list[ev->index] = change_list[nchanges];
@@ -100,8 +110,9 @@ int ngx_kqueue_del_event(ngx_event_t *ev
         return NGX_OK;
     }
 
-    if (flags & NGX_CLOSE_EVENT)
+    if (flags & NGX_CLOSE_EVENT) {
         return NGX_OK;
+    }
 
     return ngx_kqueue_set_event(ev, event, EV_DELETE);
 }
@@ -109,15 +120,17 @@ int ngx_kqueue_del_event(ngx_event_t *ev
 
 int ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
 {
-    struct timespec   ts;
-    ngx_connection_t *c;
+    struct timespec    ts;
+    ngx_connection_t  *c;
 
     c = (ngx_connection_t *) ev->data;
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(ev->log, "kqueue set event: %d: ft:%d f:%08x" _
                   c->fd _ filter _ flags);
+#endif
 
-    if (nchanges >= nevents) {
+    if (nchanges >= KQUEUE_NCHANGES) {
         ngx_log_error(NGX_LOG_WARN, ev->log, 0,
                       "kqueue change list is filled up");
 
@@ -128,6 +141,7 @@ int ngx_kqueue_set_event(ngx_event_t *ev
             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent failed");
             return NGX_ERROR;
         }
+
         nchanges = 0;
     }
 
@@ -168,7 +182,9 @@ int ngx_kqueue_process_events(ngx_log_t 
         tp = NULL;
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(log, "kevent timer: %d" _ timer);
+#endif
 
     events = kevent(kq, change_list, nchanges, event_list, nevents, tp);
 
@@ -184,38 +200,25 @@ int ngx_kqueue_process_events(ngx_log_t 
         delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
 
     } else {
-        ngx_assert((events != 0), return NGX_ERROR, log,
-                   "kevent returns no events without timeout");
-    }
-
-    ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
-
-    if (timer) {
-        if (delta >= timer) {
-            for ( ;; ) {
-                ev = timer_queue.timer_next;
-
-                if (ev == &timer_queue || delta < ev->timer_delta)
-                    break;
-
-                delta -= ev->timer_delta;
-                ngx_del_timer(ev);
-                ev->timedout = 1;
-                if (ev->event_handler(ev) == NGX_ERROR)
-                    ev->close_handler(ev);
-            }
-
-        } else {
-           timer_queue.timer_next->timer_delta -= delta;
+        if (events == 0) {
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "kevent returns no events without timeout");
+            return NGX_ERROR;
         }
     }
 
+#if (NGX_DEBUG_EVENT)
+    ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
+#endif
+
     for (i = 0; i < events; i++) {
 
+#if (NGX_DEBUG_EVENT)
         ngx_log_debug(log, "kevent: %d: ft:%d f:%08x ff:%08x d:%d ud:%08x" _
                       event_list[i].ident _ event_list[i].filter _
                       event_list[i].flags _ event_list[i].fflags _
                       event_list[i].data _ event_list[i].udata);
+#endif
 
         if (event_list[i].flags & EV_ERROR) {
             ngx_log_error(NGX_LOG_ALERT, log, event_list[i].data,
@@ -225,6 +228,10 @@ int ngx_kqueue_process_events(ngx_log_t 
 
         ev = (ngx_event_t *) event_list[i].udata;
 
+        if (!ev->active) {
+           continue;
+        }
+
         switch (event_list[i].filter) {
 
         case EVFILT_READ:
@@ -237,17 +244,42 @@ int ngx_kqueue_process_events(ngx_log_t 
                 ev->error = event_list[i].fflags;
             }
 
-            if (ev->oneshot)
+            if (ev->oneshot) {
                 ngx_del_timer(ev);
+            }
 
-            if (ev->event_handler(ev) == NGX_ERROR)
+            if (ev->event_handler(ev) == NGX_ERROR) {
                 ev->close_handler(ev);
+            }
 
             break;
 
         default:
-            ngx_assert(0, /* void */, log,
-                       "unknown kevent filter %d" _ event_list[i].filter);
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "unknown kevent filter %d" _ event_list[i].filter);
+        }
+    }
+
+    if (timer && timer_queue.timer_next != &timer_queue) {
+        if (delta >= timer_queue.timer_next->timer_delta) {
+            for ( ;; ) {
+                ev = timer_queue.timer_next;
+
+                if (ev == &timer_queue || delta < ev->timer_delta) {
+                    break;
+                }
+
+                delta -= ev->timer_delta;
+
+                ngx_del_timer(ev);
+                ev->timedout = 1;
+                if (ev->event_handler(ev) == NGX_ERROR) {
+                    ev->close_handler(ev);
+                }
+            }
+
+        } else {
+           timer_queue.timer_next->timer_delta -= delta;
         }
     }
 
@@ -257,19 +289,24 @@ int ngx_kqueue_process_events(ngx_log_t 
 
 void ngx_kqueue_add_timer(ngx_event_t *ev, ngx_msec_t timer)
 {
-    ngx_event_t *e;
+    ngx_event_t  *e;
 
-#if (NGX_DEBUG)
+#if (NGX_DEBUG_EVENT)
     ngx_connection_t *c = (ngx_connection_t *) ev->data;
     ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
 #endif
-    ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
-               "timer already set");
+
+    if (ev->timer_next || ev->timer_prev) {
+        ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
+        return;
+    }
 
     for (e = timer_queue.timer_next;
          e != &timer_queue && timer > e->timer_delta;
          e = e->timer_next)
+    {
         timer -= e->timer_delta;
+    }
 
     ev->timer_delta = timer;
 
--- a/src/event/modules/ngx_poll_module.c
+++ b/src/event/modules/ngx_poll_module.c
@@ -12,9 +12,10 @@
 
 /* should be per-thread */
 static struct pollfd  *event_list;
-static int             nevents;
+static unsigned int    nevents;
 
 static ngx_event_t   **event_index;
+static ngx_event_t   **ready_index;
 static ngx_event_t     timer_queue;
 /* */
 
@@ -28,6 +29,10 @@ int ngx_poll_init(int max_connections, n
                   ngx_alloc(sizeof(ngx_event_t *) * max_connections, log),
                   NGX_ERROR);
 
+    ngx_test_null(ready_index,
+                  ngx_alloc(sizeof(ngx_event_t *) * 2 * max_connections, log),
+                  NGX_ERROR);
+
     nevents = 0;
 
     timer_queue.timer_prev = &timer_queue;
@@ -43,11 +48,12 @@ int ngx_poll_init(int max_connections, n
 
 int ngx_poll_add_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_event_t      *e;
-    ngx_connection_t *c;
+    ngx_event_t       *e;
+    ngx_connection_t  *c;
 
     c = (ngx_connection_t *) ev->data;
 
+    ev->active = 1;
     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
 
     if (event == NGX_READ_EVENT) {
@@ -63,7 +69,9 @@ int ngx_poll_add_event(ngx_event_t *ev, 
 #endif
     }
 
-    ngx_log_debug(ev->log, "poll fd:%d event:%d" _ c->fd _ event);
+#if (NGX_DEBUG_EVENT)
+    ngx_log_debug(ev->log, "add event: %d:%d" _ c->fd _ event);
+#endif
 
     if (e == NULL || e->index == NGX_INVALID_INDEX) {
         event_list[nevents].fd = c->fd;
@@ -84,13 +92,14 @@ int ngx_poll_add_event(ngx_event_t *ev, 
 
 int ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_event_t      *e;
-    ngx_connection_t *c;
+    ngx_event_t       *e;
+    ngx_connection_t  *c;
 
     c = (ngx_connection_t *) ev->data;
 
-    if (ev->index == NGX_INVALID_INDEX)
+    if (ev->index == NGX_INVALID_INDEX) {
         return NGX_OK;
+    }
 
     if (event == NGX_READ_EVENT) {
         e = c->write;
@@ -105,7 +114,9 @@ int ngx_poll_del_event(ngx_event_t *ev, 
 #endif
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(c->log, "del event: %d, %d" _ c->fd _ event);
+#endif
 
     if (e == NULL || e->index == NGX_INVALID_INDEX) {
         if (ev->index < --nevents) {
@@ -118,6 +129,7 @@ int ngx_poll_del_event(ngx_event_t *ev, 
         event_list[e->index].events &= ~event;
     }
 
+    ev->active = 0;
     ev->index = NGX_INVALID_INDEX;
 
     return NGX_OK;
@@ -125,7 +137,7 @@ int ngx_poll_del_event(ngx_event_t *ev, 
 
 int ngx_poll_process_events(ngx_log_t *log)
 {
-    int                i, ready, found;
+    int                i, ready, nready, found;
     u_int              timer, delta;
     ngx_err_t          err;
     ngx_event_t       *ev;
@@ -140,15 +152,14 @@ int ngx_poll_process_events(ngx_log_t *l
         delta = 0;
     }
 
-#if 1
-    /* DEBUG */
+#if (NGX_DEBUG_EVENT)
     for (i = 0; i < nevents; i++) {
         ngx_log_debug(log, "poll: %d, %d" _
                       event_list[i].fd _ event_list[i].events);
     }
-#endif
 
     ngx_log_debug(log, "poll timer: %d" _ timer);
+#endif
 
     if ((ready = poll(event_list, nevents, timer)) == -1) {
         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "poll() failed");
@@ -161,70 +172,38 @@ int ngx_poll_process_events(ngx_log_t *l
         delta = ngx_msec() - delta;
 
     } else {
-        ngx_assert((ready != 0), return NGX_ERROR, log,
-                   "poll() returns no events without timeout");
+        if (ready == 0) {
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "poll() returns no events without timeout");
+            return NGX_ERROR;
+        }
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(log, "poll timer: %d, delta: %d" _ timer _ delta);
-
-    if (timer != INFTIM) {
-        if (delta >= timer) {
-            for ( ;; ) {
-                ev = timer_queue.timer_next;
-
-                if (ev == &timer_queue || delta < ev->timer_delta) {
-                    break;
-                }
+#endif
 
-                delta -= ev->timer_delta;
-                ngx_del_timer(ev);
-                ev->timedout = 1;
-
-                if (ev->event_handler(ev) == NGX_ERROR) {
-                    ev->close_handler(ev);
-                }
-            }
-
-        } else {
-           timer_queue.timer_next->timer_delta -= delta;
-        }
-    }
+    nready = 0;
 
     for (i = 0; i < nevents && ready; i++) {
         c = &ngx_connections[event_list[i].fd];
 
+#if (NGX_DEBUG_EVENT)
         ngx_log_debug(log, "poll: fd:%d, ev:%d, rev:%d" _
                       event_list[i].fd _
                       event_list[i].events _ event_list[i].revents);
+#endif
 
         found = 0;
 
         if (event_list[i].revents & POLLIN) {
             found = 1;
-            c->read->ready = 1;
-
-            if (c->read->oneshot) {
-                ngx_del_timer(c->read);
-                ngx_poll_del_event(c->read, NGX_READ_EVENT, 0);
-            }
-
-            if (c->read->event_handler(c->read) == NGX_ERROR) {
-                c->read->close_handler(c->read);
-            }
+            ready_index[nready++] = c->read;
         }
 
         if (event_list[i].revents & POLLOUT) {
             found = 1;
-            c->write->ready = 1;
-
-            if (c->write->oneshot) {
-                ngx_del_timer(c->write);
-                ngx_poll_del_event(c->write, NGX_WRITE_EVENT, 0);
-            }
-
-            if (c->write->event_handler(c->write) == NGX_ERROR) {
-                c->write->close_handler(c->write);
-            }
+            ready_index[nready++] = c->write;
         }
 
         if (event_list[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
@@ -245,7 +224,56 @@ int ngx_poll_process_events(ngx_log_t *l
         }
     }
 
-    ngx_assert((ready == 0), /* void */ ; , log, "poll ready != nevents");
+    for (i = 0; i < nready; i++) {
+        ev = ready_index[i];
+
+        if (!ev->active) {
+            continue;
+        }
+
+        ev->ready = 1;
+
+        if (ev->oneshot) {
+            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);
+            }
+        }
+
+        if (ev->event_handler(ev) == NGX_ERROR) {
+            ev->close_handler(ev);
+        }
+    }
+
+    if (ready != 0) {
+        ngx_log_error(NGX_LOG_ALERT, log, 0, "poll ready != events");
+    }
+
+    if (timer != INFTIM && timer_queue.timer_next != &timer_queue) {
+        if (delta >= timer_queue.timer_next->timer_delta) {
+            for ( ;; ) {
+                ev = timer_queue.timer_next;
+
+                if (ev == &timer_queue || delta < ev->timer_delta) {
+                    break;
+                }
+
+                delta -= ev->timer_delta;
+
+                ngx_del_timer(ev);
+                ev->timedout = 1;
+                if (ev->event_handler(ev) == NGX_ERROR) {
+                    ev->close_handler(ev);
+                }
+            }
+
+        } else {
+           timer_queue.timer_next->timer_delta -= delta;
+        }
+    }
 
     return NGX_OK;
 }
@@ -254,10 +282,22 @@ void ngx_poll_add_timer(ngx_event_t *ev,
 {
     ngx_event_t *e;
 
+#if (NGX_DEBUG_EVENT)
+    ngx_connection_t *c = (ngx_connection_t *) ev->data;
+    ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
+#endif
+
+    if (ev->timer_next || ev->timer_prev) {
+        ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
+        return;
+    }
+
     for (e = timer_queue.timer_next;
          e != &timer_queue && timer > e->timer_delta;
          e = e->timer_next)
+    {
         timer -= e->timer_delta;
+    }
 
     ev->timer_delta = timer;
 
--- a/src/event/modules/ngx_select_module.c
+++ b/src/event/modules/ngx_select_module.c
@@ -22,7 +22,7 @@ static int            max_write;
 static int            max_fd;
 #endif
 
-static int            nevents;
+static unsigned int   nevents;
 
 static ngx_event_t  **event_index;
 static ngx_event_t  **ready_index;
@@ -75,11 +75,13 @@ int ngx_select_init(int max_connections,
 
 int ngx_select_add_event(ngx_event_t *ev, int event, u_int flags)
 {
-    ngx_connection_t *c;
+    ngx_connection_t  *c;
 
     c = (ngx_connection_t *) ev->data;
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(ev->log, "select fd:%d event:%d" _ c->fd _ event);
+#endif
 
     if (ev->index != NGX_INVALID_INDEX) {
         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
@@ -117,6 +119,7 @@ int ngx_select_add_event(ngx_event_t *ev
 
 #endif
 
+    ev->active = 1;
     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1: 0;
 
     event_index[nevents] = ev;
@@ -134,7 +137,9 @@ int ngx_select_del_event(ngx_event_t *ev
     if (ev->index == NGX_INVALID_INDEX)
         return NGX_OK;
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(c->log, "del event: %d, %d" _ c->fd _ event);
+#endif
 
 #if (WIN32)
     if (event == NGX_READ_EVENT) {
@@ -161,6 +166,7 @@ int ngx_select_del_event(ngx_event_t *ev
         event_index[ev->index]->index = ev->index;
     }
 
+    ev->active = 0;
     ev->index = NGX_INVALID_INDEX;
 
     return NGX_OK;
@@ -199,20 +205,21 @@ int ngx_select_process_events(ngx_log_t 
                 max_fd = c->fd;
         }
 
+#if (NGX_DEBUG_EVENT)
         ngx_log_debug(log, "change max_fd: %d" _ max_fd);
+#endif
     }
 #endif
 
-#if 1
-    /* DEBUG */
+#if (NGX_DEBUG_EVENT)
     for (i = 0; i < nevents; i++) {
         ev = event_index[i];
         c = (ngx_connection_t *) ev->data;
         ngx_log_debug(log, "select: %d:%d" _ c->fd _ ev->write);
     }
-#endif
 
     ngx_log_debug(log, "select timer: %d" _ timer);
+#endif
 
 #if (WIN32)
     if ((ready = select(0, &work_read_fd_set, &work_write_fd_set, NULL, tp))
@@ -220,42 +227,30 @@ int ngx_select_process_events(ngx_log_t 
     if ((ready = select(max_fd + 1, &work_read_fd_set, &work_write_fd_set,
                         NULL, tp))
 #endif
-               == -1) {
+               == -1)
+    {
         ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno, "select() failed");
         return NGX_ERROR;
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(log, "select ready %d" _ ready);
+#endif
 
     if (timer) {
         delta = ngx_msec() - delta;
 
     } else {
-        ngx_assert((ready != 0), return NGX_ERROR, log,
-                   "select() returns no events without timeout");
+        if (ready == 0) {
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "select() returns no events without timeout");
+            return NGX_ERROR;
+        }
     }
 
+#if (NGX_DEBUG_EVENT)
     ngx_log_debug(log, "select timer: %d, delta: %d" _ timer _ delta);
-
-    if (timer) {
-        if (delta >= timer) {
-            for ( ;; ) {
-                ev = timer_queue.timer_next;
-
-                if (ev == &timer_queue || delta < ev->timer_delta)
-                    break;
-
-                delta -= ev->timer_delta;
-                ngx_del_timer(ev);
-                ev->timedout = 1;
-                if (ev->event_handler(ev) == NGX_ERROR)
-                    ev->close_handler(ev);
-            }
-
-        } else {
-           timer_queue.timer_next->timer_delta -= delta;
-        }
-    }
+#endif
 
     nready = 0;
 
@@ -266,14 +261,18 @@ int ngx_select_process_events(ngx_log_t 
 
         if (ev->write) {
             if (FD_ISSET(c->fd, &work_write_fd_set)) {
+                found = 1;
+#if (NGX_DEBUG_EVENT)
                 ngx_log_debug(log, "select write %d" _ c->fd);
-                found = 1;
+#endif
             }
 
         } else {
             if (FD_ISSET(c->fd, &work_read_fd_set)) {
+                found = 1;
+#if (NGX_DEBUG_EVENT)
                 ngx_log_debug(log, "select read %d" _ c->fd);
-                found = 1;
+#endif
             }
         }
 
@@ -284,6 +283,11 @@ int ngx_select_process_events(ngx_log_t 
 
     for (i = 0; i < nready; i++) {
         ev = ready_index[i];
+        ready--;
+
+        if (!ev->active) {
+            continue;
+        }
 
         ev->ready = 1;
 
@@ -298,11 +302,34 @@ int ngx_select_process_events(ngx_log_t 
 
         if (ev->event_handler(ev) == NGX_ERROR)
             ev->close_handler(ev);
+    }
 
-        ready--;
+    if (ready != 0) {
+        ngx_log_error(NGX_LOG_ALERT, log, 0, "select ready != events");
     }
 
-    ngx_assert((ready == 0), /* void */ ; , log, "select ready != events");
+    if (timer && timer_queue.timer_next != &timer_queue) {
+        if (delta >= timer_queue.timer_next->timer_delta) {
+            for ( ;; ) {
+                ev = timer_queue.timer_next;
+
+                if (ev == &timer_queue || delta < ev->timer_delta) {
+                    break;
+                }
+
+                delta -= ev->timer_delta;
+
+                ngx_del_timer(ev);
+                ev->timedout = 1;
+                if (ev->event_handler(ev) == NGX_ERROR) {
+                    ev->close_handler(ev);
+                }
+            }
+
+        } else {
+           timer_queue.timer_next->timer_delta -= delta;
+        }
+    }
 
     return NGX_OK;
 }
@@ -311,17 +338,22 @@ void ngx_select_add_timer(ngx_event_t *e
 {
     ngx_event_t *e;
 
-#if (NGX_DEBUG)
+#if (NGX_DEBUG_EVENT)
     ngx_connection_t *c = (ngx_connection_t *) ev->data;
     ngx_log_debug(ev->log, "set timer: %d:%d" _ c->fd _ timer);
 #endif
-    ngx_assert((!ev->timer_next && !ev->timer_prev), return, ev->log,
-               "timer already set");
+
+    if (ev->timer_next || ev->timer_prev) {
+        ngx_log_error(NGX_LOG_ALERT, ev->log, 0, "timer already set");
+        return;
+    }
 
     for (e = timer_queue.timer_next;
          e != &timer_queue && timer > e->timer_delta;
          e = e->timer_next)
+    {
         timer -= e->timer_delta;
+    }
 
     ev->timer_delta = timer;
 
--- a/src/event/ngx_event.c
+++ b/src/event/ngx_event.c
@@ -15,6 +15,9 @@
 #if (HAVE_POLL)
 #include <ngx_poll_module.h>
 #endif
+#if (HAVE_DEVPOLL)
+#include <ngx_devpoll_module.h>
+#endif
 #if (HAVE_KQUEUE)
 #include <ngx_kqueue_module.h>
 #endif
@@ -29,18 +32,20 @@ ngx_event_t         *ngx_read_events, *n
 
 #if 0
 ngx_event_type_e     ngx_event_type = NGX_SELECT_EVENT;
-#elif 1
+#elif 0
 ngx_event_type_e     ngx_event_type = NGX_POLL_EVENT;
 #else
 ngx_event_type_e     ngx_event_type = NGX_KQUEUE_EVENT;
 #endif
 
-#elif (HAVE_POLL)
+#elif (HAVE_DEVPOLL)
 
 #if 0
 ngx_event_type_e     ngx_event_type = NGX_SELECT_EVENT;
+#elif 0
+ngx_event_type_e     ngx_event_type = NGX_POLL_EVENT;
 #else
-ngx_event_type_e     ngx_event_type = NGX_POLL_EVENT;
+ngx_event_type_e     ngx_event_type = NGX_DEVPOLL_EVENT;
 #endif
 
 #else
@@ -57,6 +62,9 @@ static int (*ngx_event_init[]) (int max_
 #if (HAVE_POLL)
     ngx_poll_init,
 #endif
+#if (HAVE_DEVPOLL)
+    ngx_devpoll_init,
+#endif
 #if (HAVE_KQUEUE)
     ngx_kqueue_init
 #endif
--- a/src/event/ngx_event.h
+++ b/src/event/ngx_event.h
@@ -51,6 +51,7 @@ struct ngx_event_s {
     unsigned         listening:1;
     unsigned         write:1;
 
+    unsigned         active:1;
     unsigned         ready:1;
     unsigned         timedout:1;
     unsigned         blocked:1;
@@ -74,6 +75,9 @@ typedef enum {
 #if (HAVE_POLL)
     NGX_POLL_EVENT,
 #endif
+#if (HAVE_DEVPOLL)
+    NGX_DEVPOLL_EVENT,
+#endif
 #if (HAVE_KQUEUE)
     NGX_KQUEUE_EVENT,
 #endif
@@ -120,7 +124,7 @@ NGX_CLOSE_EVENT            kqueue: kqueu
 #define NGX_CLEAR_EVENT    EV_CLEAR
 #endif
 
-#elif (HAVE_POLL)
+#elif (HAVE_POLL) || (HAVE_DEVPOLL)
 
 #define NGX_READ_EVENT     POLLIN
 #define NGX_WRITE_EVENT    POLLOUT
@@ -159,9 +163,10 @@ NGX_CLOSE_EVENT            kqueue: kqueu
 #endif
 
 
-static void ngx_inline ngx_del_timer(ngx_event_t *ev)
+ngx_inline static void ngx_del_timer(ngx_event_t *ev)
 {
-#if (NGX_DEBUG)
+#if (NGX_DEBUG_EVENT)
+    /* STUB - we can not cast (ngx_connection_t *) here */
     ngx_log_debug(ev->log, "del timer: %d" _ *(int *)(ev->data));
 #endif
 
--- a/src/http/ngx_http.c
+++ b/src/http/ngx_http.c
@@ -34,6 +34,7 @@ int ngx_http_init(ngx_pool_t *pool, ngx_
     ngx_http_server.doc_root = "/home/is/dox/";
     ngx_http_server.doc_root = "/home/is/work/xml/site-1.0.0/html";
     ngx_http_server.doc_root = "/spool/test/lperltk";
+    ngx_http_server.doc_root = "/home/is/dox/ora/lperltk";
 #endif
     ngx_http_server.doc_root_len = strlen(ngx_http_server.doc_root) + 1;
 
--- a/src/http/ngx_http_core.c
+++ b/src/http/ngx_http_core.c
@@ -350,7 +350,10 @@ static void *ngx_http_core_create_loc_co
                   ngx_pcalloc(pool, sizeof(ngx_http_core_loc_conf_t)),
                   NULL);
 
+    conf->send_timeout = 10;
+/*
     conf->send_timeout = NGX_CONF_UNSET;
+*/
 
     return conf;
 }
--- a/src/http/ngx_http_event.c
+++ b/src/http/ngx_http_event.c
@@ -549,7 +549,7 @@ static int ngx_http_writer(ngx_event_t *
 
     if (!r->keepalive) {
         if (r->lingering_close) {
-            ngx_http_set_lingering_close(r);
+            return ngx_http_set_lingering_close(r);
 
         } else {
             return ngx_http_close_request(r);