diff --git a/src/event/modules/ngx_kqueue_module.c b/src/event/modules/ngx_kqueue_module.c
index e88b474..51541d7 100644
--- a/src/event/modules/ngx_kqueue_module.c
+++ b/src/event/modules/ngx_kqueue_module.c
@@ -34,9 +34,10 @@
     nchanges = 0;
     nevents = 512;
 
-    if ((kq = kqueue()) == -1) {
-        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
-                      "kqueue() failed");
+    kq = kqueue();
+
+    if (kq == -1) {
+        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "kqueue() failed");
         exit(1);
     }
 
@@ -52,7 +53,6 @@
     ngx_event_actions.timer = ngx_kqueue_add_timer;
     ngx_event_actions.process = ngx_kqueue_process_events;
 #endif
-
 }
 
 int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
@@ -72,7 +72,7 @@
     struct timespec  ts = { 0, 0 };
     ngx_connection_t *cn = (ngx_connection_t *) ev->data;
 
-    ngx_log_debug(ev->log, "ngx_kqueue_set_event: %d: ft:%d f:%08x" _
+    ngx_log_debug(ev->log, "kqueue set event: %d: ft:%d f:%08x" _
                   cn->fd _ filter _ flags);
 
     if (nchanges >= nevents) {
@@ -80,9 +80,8 @@
                       "ngx_kqueue_set_event: change list is filled up");
 
         if (kevent(kq, change_list, nchanges, NULL, 0, &ts) == -1) {
-            ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
-                          "ngx_kqueue_set_event: kevent failed");
-            return -1;
+            ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent failed");
+            return NGX_ERROR;
         }
         nchanges = 0;
     }
@@ -95,7 +94,7 @@
     change_list[nchanges].udata = ev;
     nchanges++;
 
-    return 0;
+    return NGX_OK;
 }
 
 int ngx_kqueue_process_events(ngx_log_t *log)
@@ -115,13 +114,12 @@
         delta = tv.tv_sec * 1000 + tv.tv_usec / 1000;
     }
 
-    ngx_log_debug(log, "ngx_kqueue_process_events: timer: %d" _ timer);
+    ngx_log_debug(log, "kevent timer: %d" _ timer);
 
-    if ((events = kevent(kq, change_list, nchanges, event_list, nevents, tp))
-                == -1) {
-        ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
-                      "ngx_kqueue_process_events: kevent failed");
-        return -1;
+    events = kevent(kq, change_list, nchanges, event_list, nevents, tp);
+    if (events == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "kevent failed");
+        return NGX_ERROR;
     }
 
     nchanges = 0;
@@ -131,13 +129,11 @@
         delta = tv.tv_sec * 1000 + tv.tv_usec / 1000 - delta;
 
     } else {
-        ngx_assert((events != 0), return -1, log,
-                   "ngx_kqueue_process_events: "
+        ngx_assert((events != 0), return NGX_ERROR, log,
                    "kevent returns no events without timeout");
     }
 
-    ngx_log_debug(log, "ngx_kqueue_process_events: "
-                  "timer: %d, delta: %d" _ timer _ delta);
+    ngx_log_debug(log, "kevent timer: %d, delta: %d" _ timer _ delta);
 
     if (timer) {
         if (delta >= timer) {
@@ -161,16 +157,14 @@
 
     for (i = 0; i < events; i++) {
 
-        ngx_log_debug(log, "ngx_kqueue_process_events: kevent: "
-                      "%d: ft:%d f:%08x ff:%08x d:%d ud:%08x" _
+        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);
 
         if (event_list[i].flags & EV_ERROR) {
             ngx_log_error(NGX_LOG_ALERT, log, event_list[i].data,
-                          "ngx_kqueue_process_events: kevent error on %d",
-                          event_list[i].ident);
+                          "kevent error on %d", event_list[i].ident);
             continue;
         }
 
@@ -198,12 +192,11 @@
 
         default:
             ngx_assert(0, /* void */, log,
-                       "ngx_kqueue_process_events: unknown filter %d" _
-                       event_list[i].filter);
+                       "unknown kevent filter %d" _ event_list[i].filter);
         }
     }
 
-    return 0;
+    return NGX_OK;
 }
 
 void ngx_kqueue_add_timer(ngx_event_t *ev, ngx_msec_t timer)
diff --git a/src/http/ngx_http.h b/src/http/ngx_http.h
index 6968dee..b7f0101 100644
--- a/src/http/ngx_http.h
+++ b/src/http/ngx_http.h
@@ -18,11 +18,12 @@
 #define NGX_HTTP_CONN_KEEP_ALIVE  1
 
 
-#define NGX_HTTP_HEADER_DONE            1
-#define NGX_HTTP_INVALID_METHOD         10
-#define NGX_HTTP_INVALID_REQUEST        11
-#define NGX_HTTP_INVALID_HEAD           12
-#define NGX_HTTP_INVALID_HEADER         13
+#define NGX_HTTP_PARSE_HEADER_DONE      1
+#define NGX_HTTP_PARSE_INVALID_METHOD   10
+#define NGX_HTTP_PARSE_INVALID_REQUEST  11
+#define NGX_HTTP_PARSE_TOO_LONG_URI     12
+#define NGX_HTTP_PARSE_INVALID_HEAD     13
+#define NGX_HTTP_PARSE_INVALID_HEADER   14
 
 
 #define NGX_HTTP_OK                     200
@@ -30,6 +31,7 @@
 #define NGX_HTTP_MOVED_PERMANENTLY      302
 #define NGX_HTTP_BAD_REQUEST            400
 #define NGX_HTTP_NOT_FOUND              404
+#define NGX_HTTP_REQUEST_URI_TOO_LARGE  414
 #define NGX_HTTP_INTERNAL_SERVER_ERROR  503
 
 
@@ -116,8 +118,10 @@
     unsigned  keepalive:1;
     unsigned  lingering_close:1;
 
-    unsigned  header_timeout:1;
     unsigned  process_header:1;
+    unsigned  header_timeout:1;
+
+    unsigned  logging:1;
 
     unsigned  header_only:1;
     unsigned  unusual_uri:1;
diff --git a/src/http/ngx_http_event.c b/src/http/ngx_http_event.c
index 818a70e..669f6d6 100644
--- a/src/http/ngx_http_event.c
+++ b/src/http/ngx_http_event.c
@@ -1,3 +1,7 @@
+/*
+   TODO Win32 inet_ntoa
+        ngx_inet_ntop
+*/
 
 #include <ngx_config.h>
 #include <ngx_core.h>
@@ -36,7 +40,7 @@
 static int ngx_http_set_default_handler(ngx_http_request_t *r);
 
 static int ngx_http_writer(ngx_event_t *ev);
-
+static int ngx_http_keepalive_handler(ngx_event_t *ev);
 static int ngx_http_lingering_close(ngx_event_t *ev);
 
 static int ngx_http_special_response(ngx_http_request_t *r, int error);
@@ -47,13 +51,11 @@
 static size_t ngx_http_log_error(void *data, char *buf, size_t len);
 
 
-/* STUB */
-static int ngx_http_writer(ngx_event_t *ev);
-
 
 static char *header_errors[] = {
     "client %s sent invalid method",
     "client %s sent invalid request",
+    "client %s sent too long URI",
     "client %s sent HEAD method in HTTP/0.9 request"
 };
 
@@ -68,8 +70,9 @@
     ev = c->read;
     ev->event_handler = ngx_http_init_request;
 
-    /* TODO: connection's pool size */
-    ngx_test_null(c->pool, ngx_create_pool(1024, ev->log), NGX_ERROR);
+    ngx_test_null(c->pool,
+                  ngx_create_pool(srv->connection_pool_size, ev->log),
+                  NGX_ERROR);
 
     ngx_test_null(addr, ngx_palloc(c->pool, c->socklen), NGX_ERROR);
     ngx_memcpy(addr, c->sockaddr, c->socklen);
@@ -78,10 +81,7 @@
     ngx_test_null(c->addr_text, ngx_palloc(c->pool, c->addr_textlen),
                   NGX_ERROR);
 #if (WIN32)
-/*
     c->addr_text = inet_ntoa((struct in_addr) ((char *)c->sockaddr + c->addr));
-*/
-    c->addr_text = NULL;
 #else
     inet_ntop(c->family, (char *)c->sockaddr + c->addr,
               c->addr_text, c->addr_textlen);
@@ -121,7 +121,7 @@
 }
 
 
-int ngx_http_init_request(ngx_event_t *ev)
+static int ngx_http_init_request(ngx_event_t *ev)
 {
     ngx_connection_t    *c;
     ngx_http_server_t   *srv;
@@ -130,12 +130,22 @@
     c = (ngx_connection_t *) ev->data;
     srv = (ngx_http_server_t *) c->server;
 
+    if (c->buffer == NULL) {
+        ngx_test_null(c->buffer,
+                      ngx_create_temp_hunk(c->pool, srv->header_buffer_size,
+                                           0, 0),
+                      NGX_ERROR);
+    } else {
+        c->buffer->pos.mem = c->buffer->last.mem = c->buffer->start;
+    }
+
     ngx_test_null(r, ngx_pcalloc(c->pool, sizeof(ngx_http_request_t)),
                   NGX_ERROR);
 
     c->data = r;
     r->connection = c;
     r->server = srv;
+    r->header_in = c->buffer;
 
     r->srv_conf = ngx_srv_conf;
     r->loc_conf = ngx_loc_conf;
@@ -146,13 +156,10 @@
     ngx_test_null(r->ctx, ngx_pcalloc(r->pool, sizeof(void *) * ngx_max_module),
                   ngx_http_close_request(r));
 
-    ngx_test_null(r->header_in,
-                  ngx_create_temp_hunk(r->pool, srv->header_buffer_size, 0, 0),
-                  ngx_http_close_request(r));
-
     ev->event_handler = ngx_http_process_request;
     r->state_handler = ngx_http_process_request_line;
     r->process_header = 1;
+    r->header_timeout = 1;
 
     return ngx_http_process_request(ev);
 }
@@ -163,6 +170,7 @@
     int n, rc;
     ngx_connection_t *c ;
     ngx_http_request_t *r;
+    ngx_http_log_ctx_t  *ctx;
 
     c = (ngx_connection_t *) ev->data;
     r = (ngx_http_request_t *) c->data;
@@ -173,8 +181,8 @@
                        r->header_in->end - r->header_in->last.mem);
 
     if (n == NGX_AGAIN) {
-        if (!r->header_timeout) {
-            r->header_timeout = 1;
+        if (r->header_timeout) {
+            r->header_timeout = 0;
             ngx_del_timer(ev);
             ngx_add_timer(ev, r->server->header_timeout);
         }
@@ -210,8 +218,8 @@
     } while (r->process_header
              && r->header_in->pos.mem < r->header_in->last.mem);
 
-    if (!r->header_timeout) {
-        r->header_timeout = 1;
+    if (r->header_timeout) {
+        r->header_timeout = 0;
         ngx_del_timer(ev);
         ngx_add_timer(ev, r->server->header_timeout);
     }
@@ -219,6 +227,7 @@
     return rc;
 }
 
+
 static int ngx_http_process_request_line(ngx_http_request_t *r)
 {
     int rc;
@@ -238,6 +247,8 @@
         if (r->http_version == 9)
             return ngx_http_handler(r);
 
+        /* TODO: check too long URI - no space for header, compact buffer */
+
         r->state_handler = ngx_http_process_request_header;
         ctx = r->connection->log->data;
         ctx->action = "reading client request headers";
@@ -245,15 +256,26 @@
         return NGX_OK;
     }
 
+    if (r->header_in->last.mem >= r->header_in->end) {
+        rc == NGX_HTTP_PARSE_TOO_LONG_URI;
+
+    } else if (rc == NGX_AGAIN) {
+        return NGX_AGAIN;
+    }
+
     ctx = r->connection->log->data;
     r->connection->log->handler = NULL;
-    ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                  header_errors[rc - NGX_HTTP_INVALID_METHOD], ctx->client);
+    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                  header_errors[rc - NGX_HTTP_PARSE_INVALID_METHOD],
+                  ctx->client);
     r->connection->log->handler = ngx_http_log_error;
 
-    return ngx_http_error(r, NGX_HTTP_BAD_REQUEST);
+    return ngx_http_error(r, (rc == NGX_HTTP_PARSE_TOO_LONG_URI) ?
+                                 NGX_HTTP_REQUEST_URI_TOO_LARGE:
+                                 NGX_HTTP_BAD_REQUEST);
 }
 
+
 static int ngx_http_process_request_header(ngx_http_request_t *r)
 {
     int rc;
@@ -262,21 +284,23 @@
     for ( ;; ) {
         rc = ngx_read_http_header_line(r);
 
+        /* TODO: check too long header, compact buffer */
+
         if (rc == NGX_OK) {
             if (ngx_http_process_request_header_line(r) == NGX_ERROR)
                 return ngx_http_error(r, NGX_HTTP_BAD_REQUEST);
 
-        } else if (rc == NGX_HTTP_HEADER_DONE) {
+        } else if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
             ngx_log_debug(r->connection->log, "HTTP header done");
             return ngx_http_handler(r);
 
         } else if (rc == NGX_AGAIN) {
             return NGX_AGAIN;
 
-        } else if (rc == NGX_HTTP_INVALID_HEADER) {
+        } else if (rc == NGX_HTTP_PARSE_INVALID_HEADER) {
             ctx = r->connection->log->data;
             r->connection->log->handler = NULL;
-            ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
                           "client %s sent invalid header", ctx->client);
             r->connection->log->handler = ngx_http_log_error;
 
@@ -285,6 +309,7 @@
     }
 }
 
+
 static int ngx_http_process_request_header_line(ngx_http_request_t *r)
 {
     /* STUB */
@@ -296,13 +321,8 @@
     return NGX_OK;
 }
 
-static int ngx_http_block_read(ngx_event_t *ev)
-{
-    ngx_log_debug(ev->log, "http read blocked");
 
-    ngx_del_event(ev, NGX_READ_EVENT);
-    ev->blocked = 1;
-}
+/* ******************** */
 
 void ngx_http_discard_body(ngx_http_request_t *r)
 {
@@ -375,13 +395,15 @@
     return n;
 }
 
+/* ******************** */
+
 static int ngx_http_handler(ngx_http_request_t *r)
 {
     int  rc;
     ngx_msec_t  timeout;
 
     ngx_del_timer(r->connection->read);
-    r->header_timeout = 1;
+    r->header_timeout = 0;
 
     r->process_header = 0;
     r->state_handler = NULL;
@@ -408,7 +430,6 @@
         if (ngx_add_event(r->connection->write, NGX_WRITE_EVENT,
                           NGX_ONESHOT_EVENT) == NGX_ERROR) {
 #endif
-            /* log http request */
             return ngx_http_close_request(r);
         }
 
@@ -460,49 +481,6 @@
     }
 }
 
-static int ngx_http_lingering_close(ngx_event_t *ev)
-{
-    ssize_t  n;
-    ngx_msec_t   timer;
-    ngx_connection_t    *c;
-    ngx_http_request_t  *r;
-
-    c = (ngx_connection_t *) ev->data;
-    r = (ngx_http_request_t *) c->data;
-
-    ngx_log_debug(ev->log, "http lingering close");
-
-    if (ev->timedout)
-        return NGX_DONE;
-
-    /* STUB */
-    timer = r->lingering_time - ngx_time();
-    if (timer <= 0)
-        return NGX_DONE;
-
-    if (r->discarded_buffer == NULL)
-        ngx_test_null(r->discarded_buffer,
-                      ngx_palloc(r->pool, r->server->discarded_buffer_size),
-                      NGX_ERROR);
-
-    n = ngx_event_recv(c, r->discarded_buffer,
-                       r->server->discarded_buffer_size);
-
-    if (n == NGX_ERROR)
-        return NGX_ERROR;
-
-    if (n == 0)
-        return NGX_DONE;
-
-    if (timer > LINGERING_TIMEOUT)
-        timer = LINGERING_TIMEOUT;
-
-    ngx_del_timer(ev);
-    ngx_add_timer(ev, timer * 1000);
-
-    return NGX_OK;
-}
-
 int ngx_http_internal_redirect(ngx_http_request_t *r, char *uri)
 {
     ngx_log_debug(r->connection->log, "internal redirect: '%s'" _ uri);
@@ -566,6 +544,15 @@
 }
 
 
+static int ngx_http_block_read(ngx_event_t *ev)
+{
+    ngx_log_debug(ev->log, "http read blocked");
+
+    ngx_del_event(ev, NGX_READ_EVENT);
+    ev->blocked = 1;
+}
+
+
 static int ngx_http_writer(ngx_event_t *ev)
 {
     int rc;
@@ -644,6 +631,11 @@
     ngx_connection_t    *c;
     ngx_http_log_ctx_t  *ctx;
 
+    ngx_log_debug(ev->log, "http keepalive");
+
+    if (ev->timedout)
+        return NGX_DONE;
+
     if (closed)
         /* NGX_LOG_INFO or even silent */
         return NGX_ERROR;
@@ -659,6 +651,49 @@
 
 #endif
 
+static int ngx_http_lingering_close(ngx_event_t *ev)
+{
+    ssize_t  n;
+    ngx_msec_t   timer;
+    ngx_connection_t    *c;
+    ngx_http_request_t  *r;
+
+    c = (ngx_connection_t *) ev->data;
+    r = (ngx_http_request_t *) c->data;
+
+    ngx_log_debug(ev->log, "http lingering close");
+
+    if (ev->timedout)
+        return NGX_DONE;
+
+    /* STUB */
+    timer = r->lingering_time - ngx_time();
+    if (timer <= 0)
+        return NGX_DONE;
+
+    if (r->discarded_buffer == NULL)
+        ngx_test_null(r->discarded_buffer,
+                      ngx_palloc(r->pool, r->server->discarded_buffer_size),
+                      NGX_ERROR);
+
+    n = ngx_event_recv(c, r->discarded_buffer,
+                       r->server->discarded_buffer_size);
+
+    if (n == NGX_ERROR)
+        return NGX_ERROR;
+
+    if (n == 0)
+        return NGX_DONE;
+
+    if (timer > LINGERING_TIMEOUT)
+        timer = LINGERING_TIMEOUT;
+
+    ngx_del_timer(ev);
+    ngx_add_timer(ev, timer * 1000);
+
+    return NGX_OK;
+}
+
 
 static int ngx_http_special_response(ngx_http_request_t *r, int error)
 {
diff --git a/src/http/ngx_http_output_filter.c b/src/http/ngx_http_output_filter.c
index 04b3b10..462b2f5 100644
--- a/src/http/ngx_http_output_filter.c
+++ b/src/http/ngx_http_output_filter.c
@@ -65,9 +65,6 @@
         ctx->next_filter = ngx_http_output_next_filter;
     }
 
-    ngx_log_debug(r->connection->log, "HUNK: x%x CTX-IN: x%x CTX->HUNK: x%x" _
-                  hunk _ ctx->in _ ctx->hunk);
-
     if (hunk && (hunk->type & NGX_HUNK_LAST))
         ctx->last = 1;
 
diff --git a/src/http/ngx_http_parse.c b/src/http/ngx_http_parse.c
index d4caddc..155dec6 100644
--- a/src/http/ngx_http_parse.c
+++ b/src/http/ngx_http_parse.c
@@ -32,7 +32,7 @@
        state, p, r->header_in->last, ch, p);
 */
 
-        /* GCC 2.95.2 and VC 6.0 compiles switch as jump table */
+        /* GCC 2.95.2 and VC 6.0 compiles this switch as jump table */
 
         switch (state) {
 
@@ -44,7 +44,7 @@
                     return NGX_AGAIN;
 
                 if (*p != 'E' || *(p + 1) != 'T')
-                    return NGX_HTTP_INVALID_METHOD;
+                    return NGX_HTTP_PARSE_INVALID_METHOD;
 
                 r->method = NGX_HTTP_GET;
                 p += 2;
@@ -55,7 +55,7 @@
                     return NGX_AGAIN;
 
                 if (*p != 'E' || *(p + 1) != 'A' || *(p + 2) != 'D')
-                    return NGX_HTTP_INVALID_METHOD;
+                    return NGX_HTTP_PARSE_INVALID_METHOD;
 
                 r->method = NGX_HTTP_HEAD;
                 p += 3;
@@ -66,14 +66,14 @@
                     return NGX_AGAIN;
 
                 if (*p != 'O' || *(p + 1) != 'S' || *(p + 2) != 'T')
-                    return NGX_HTTP_INVALID_METHOD;
+                    return NGX_HTTP_PARSE_INVALID_METHOD;
 
                 r->method = NGX_HTTP_POST;
                 p += 3;
                 break;
 
             default:
-                return NGX_HTTP_INVALID_METHOD;
+                return NGX_HTTP_PARSE_INVALID_METHOD;
             }
 
             state = sw_space_after_method;
@@ -86,7 +86,7 @@
                 state = sw_spaces_before_uri;
                 break;
             default:
-                return NGX_HTTP_INVALID_METHOD;
+                return NGX_HTTP_PARSE_INVALID_METHOD;
             }
             break;
 
@@ -210,7 +210,7 @@
                 state = sw_http_version;
                 break;
             default:
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
             }
             break;
 
@@ -223,7 +223,7 @@
             }
 
             if (ch != 'T' || *p != 'T' || *(p + 1) != 'P' || *(p + 2) != '/')
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
 
             p += 3;
             state = sw_first_major_digit;
@@ -232,7 +232,7 @@
         /* first digit of major HTTP version */
         case sw_first_major_digit:
             if (ch < '1' || ch > '9')
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
 
             r->http_major = ch - '0';
             state = sw_major_digit;
@@ -246,7 +246,7 @@
             }
 
             if (ch < '0' || ch > '9')
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
 
             r->http_major = r->http_major * 10 + ch - '0';
             break;
@@ -254,7 +254,7 @@
         /* first digit of minor HTTP version */
         case sw_first_minor_digit:
             if (ch < '0' || ch > '9')
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
 
             r->http_minor = ch - '0';
 
@@ -274,7 +274,7 @@
             }
 
             if (ch < '0' || ch > '9')
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
 
             r->http_minor = r->http_minor * 10 + ch - '0';
             break;
@@ -286,7 +286,7 @@
                 state = sw_done;
                 break;
             default:
-                return NGX_HTTP_INVALID_REQUEST;
+                return NGX_HTTP_PARSE_INVALID_REQUEST;
             }
             break;
         }
@@ -298,7 +298,7 @@
         r->http_version = r->http_major * 1000 + r->http_minor;
         r->state = sw_start;
         if (r->http_version == 9 && r->method == NGX_HTTP_HEAD)
-            return NGX_HTTP_INVALID_HEAD;
+            return NGX_HTTP_PARSE_INVALID_HEAD;
         else
             return NGX_OK;
     } else {
@@ -358,7 +358,7 @@
                 if (ch >= '0' && ch <= '9')
                     break;
 
-                return NGX_HTTP_INVALID_HEADER;
+                return NGX_HTTP_PARSE_INVALID_HEADER;
 
             }
             break;
@@ -381,7 +381,7 @@
             if (ch >= '0' && ch <= '9')
                 break;
 
-            return NGX_HTTP_INVALID_HEADER;
+            return NGX_HTTP_PARSE_INVALID_HEADER;
 
         /* space* before header value */
         case sw_space_before_value:
@@ -445,7 +445,7 @@
                 state = sw_done;
                 break;
             default:
-                return NGX_HTTP_INVALID_HEADER;
+                return NGX_HTTP_PARSE_INVALID_HEADER;
             }
             break;
 
@@ -456,7 +456,7 @@
                 state = sw_header_done;
                 break;
             default:
-                return NGX_HTTP_INVALID_HEADER;
+                return NGX_HTTP_PARSE_INVALID_HEADER;
             }
             break;
         }
@@ -469,7 +469,7 @@
         return NGX_OK;
     } else if (state == sw_header_done) {
         r->state = sw_start;
-        return NGX_HTTP_HEADER_DONE;
+        return NGX_HTTP_PARSE_HEADER_DONE;
     } else {
         r->state = state;
         return NGX_AGAIN;