nginxtra 1.6.3.9 → 1.8.0.9

data/vendor/nginx/src/http/ngx_http_spdy.c

@@ -103,10 +103,10 @@ static u_char *ngx_http_spdy_state_syn_stream(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end);
 static u_char *ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end);
-static u_char *ngx_http_spdy_state_headers_error(ngx_http_spdy_connection_t *sc,
-    u_char *pos, u_char *end);
 static u_char *ngx_http_spdy_state_headers_skip(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end);
+static u_char *ngx_http_spdy_state_headers_error(ngx_http_spdy_connection_t *sc,
+    u_char *pos, u_char *end);
 static u_char *ngx_http_spdy_state_window_update(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end);
 static u_char *ngx_http_spdy_state_data(ngx_http_spdy_connection_t *sc,
@@ -125,6 +125,9 @@ static u_char *ngx_http_spdy_state_complete(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end);
 static u_char *ngx_http_spdy_state_save(ngx_http_spdy_connection_t *sc,
     u_char *pos, u_char *end, ngx_http_spdy_handler_pt handler);
+
+static u_char *ngx_http_spdy_state_inflate_error(
+    ngx_http_spdy_connection_t *sc, int rc);
 static u_char *ngx_http_spdy_state_protocol_error(
     ngx_http_spdy_connection_t *sc);
 static u_char *ngx_http_spdy_state_internal_error(
@@ -392,8 +395,7 @@ ngx_http_spdy_init(ngx_event_t *rev)
     c = rev->data;
     hc = c->data;
 
-    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
-                   "init spdy request");
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "init spdy request");
 
     c->log->action = "processing SPDY";
 
@@ -421,12 +423,8 @@ ngx_http_spdy_init(ngx_event_t *rev)
 
     sc->init_window = NGX_SPDY_INIT_STREAM_WINDOW;
 
-    sc->handler = ngx_http_spdy_state_head;
-
-    if (hc->proxy_protocol) {
-        c->log->action = "reading PROXY protocol";
-        sc->handler = ngx_http_spdy_proxy_protocol;
-    }
+    sc->handler = hc->proxy_protocol ? ngx_http_spdy_proxy_protocol
+                                     : ngx_http_spdy_state_head;
 
     sc->zstream_in.zalloc = ngx_http_spdy_zalloc;
     sc->zstream_in.zfree = ngx_http_spdy_zfree;
@@ -557,7 +555,7 @@ ngx_http_spdy_read_handler(ngx_event_t *rev)
 
         if (n == 0 && (sc->incomplete || sc->processing)) {
             ngx_log_error(NGX_LOG_INFO, c->log, 0,
-                          "client closed prematurely connection");
+                          "client prematurely closed connection");
         }
 
         if (n == 0 || n == NGX_ERROR) {
@@ -645,7 +643,7 @@ ngx_http_spdy_write_handler(ngx_event_t *wev)
         stream->handled = 0;
 
         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
-                       "spdy run stream %ui", stream->id);
+                       "run spdy stream %ui", stream->id);
 
         wev = stream->request->connection->write;
         wev->handler(wev);
@@ -664,6 +662,7 @@ ngx_http_spdy_write_handler(ngx_event_t *wev)
 ngx_int_t
 ngx_http_spdy_send_output_queue(ngx_http_spdy_connection_t *sc)
 {
+    int                         tcp_nodelay;
     ngx_chain_t                *cl;
     ngx_event_t                *wev;
     ngx_connection_t           *c;
@@ -702,20 +701,52 @@ ngx_http_spdy_send_output_queue(ngx_http_spdy_connection_t *sc)
     cl = c->send_chain(c, cl, 0);
 
     if (cl == NGX_CHAIN_ERROR) {
-        c->error = 1;
-
-        if (!sc->blocked) {
-            ngx_post_event(wev, &ngx_posted_events);
-        }
-
-        return NGX_ERROR;
+        goto error;
     }
 
     clcf = ngx_http_get_module_loc_conf(sc->http_connection->conf_ctx,
                                         ngx_http_core_module);
 
     if (ngx_handle_write_event(wev, clcf->send_lowat) != NGX_OK) {
-        return NGX_ERROR; /* FIXME */
+        goto error;
+    }
+
+    if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+        if (ngx_tcp_push(c->fd) == -1) {
+            ngx_connection_error(c, ngx_socket_errno, ngx_tcp_push_n " failed");
+            goto error;
+        }
+
+        c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
+        tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;
+
+    } else {
+        tcp_nodelay = 1;
+    }
+
+    if (tcp_nodelay
+        && clcf->tcp_nodelay
+        && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET)
+    {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");
+
+        if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
+                       (const void *) &tcp_nodelay, sizeof(int))
+            == -1)
+        {
+#if (NGX_SOLARIS)
+            /* Solaris returns EINVAL if a socket has been shut down */
+            c->log_error = NGX_ERROR_IGNORE_EINVAL;
+#endif
+
+            ngx_connection_error(c, ngx_socket_errno,
+                                 "setsockopt(TCP_NODELAY) failed");
+
+            c->log_error = NGX_ERROR_INFO;
+            goto error;
+        }
+
+        c->tcp_nodelay = NGX_TCP_NODELAY_SET;
     }
 
     if (cl) {
@@ -753,6 +784,16 @@ ngx_http_spdy_send_output_queue(ngx_http_spdy_connection_t *sc)
     sc->last_out = frame;
 
     return NGX_OK;
+
+error:
+
+    c->error = 1;
+
+    if (!sc->blocked) {
+        ngx_post_event(wev, &ngx_posted_events);
+    }
+
+    return NGX_ERROR;
 }
 
 
@@ -820,14 +861,19 @@ static u_char *
 ngx_http_spdy_proxy_protocol(ngx_http_spdy_connection_t *sc, u_char *pos,
     u_char *end)
 {
+    ngx_log_t  *log;
+
+    log = sc->connection->log;
+    log->action = "reading PROXY protocol";
+
     pos = ngx_proxy_protocol_parse(sc->connection, pos, end);
 
+    log->action = "processing SPDY";
+
     if (pos == NULL) {
         return ngx_http_spdy_state_protocol_error(sc);
     }
 
-    sc->connection->log->action = "processing SPDY";
-
     return ngx_http_spdy_state_complete(sc, pos, end);
 }
 
@@ -856,7 +902,7 @@ ngx_http_spdy_state_head(ngx_http_spdy_connection_t *sc, u_char *pos,
     pos += sizeof(uint32_t);
 
     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy process frame head:%08XD f:%Xd l:%uz",
+                   "process spdy frame head:%08XD f:%Xd l:%uz",
                    head, sc->flags, sc->length);
 
     if (ngx_spdy_ctl_frame_check(head)) {
@@ -868,6 +914,8 @@ ngx_http_spdy_state_head(ngx_http_spdy_connection_t *sc, u_char *pos,
             return ngx_http_spdy_state_syn_stream(sc, pos, end);
 
         case NGX_SPDY_SYN_REPLY:
+            ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                          "client sent unexpected SYN_REPLY frame");
             return ngx_http_spdy_state_protocol_error(sc);
 
         case NGX_SPDY_RST_STREAM:
@@ -883,6 +931,8 @@ ngx_http_spdy_state_head(ngx_http_spdy_connection_t *sc, u_char *pos,
             return ngx_http_spdy_state_skip(sc, pos, end); /* TODO */
 
         case NGX_SPDY_HEADERS:
+            ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                          "client sent unexpected HEADERS frame");
             return ngx_http_spdy_state_protocol_error(sc);
 
         case NGX_SPDY_WINDOW_UPDATE:
@@ -900,10 +950,8 @@ ngx_http_spdy_state_head(ngx_http_spdy_connection_t *sc, u_char *pos,
         return ngx_http_spdy_state_data(sc, pos, end);
     }
 
-
-    /* TODO version & type check */
-    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy unknown frame");
+    ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                  "client sent invalid frame");
 
     return ngx_http_spdy_state_protocol_error(sc);
 }
@@ -923,7 +971,10 @@ ngx_http_spdy_state_syn_stream(ngx_http_spdy_connection_t *sc, u_char *pos,
     }
 
     if (sc->length <= NGX_SPDY_SYN_STREAM_SIZE) {
-        /* TODO logging */
+        ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                      "client sent SYN_STREAM frame with incorrect length %uz",
+                      sc->length);
+
         return ngx_http_spdy_state_protocol_error(sc);
     }
 
@@ -937,13 +988,34 @@ ngx_http_spdy_state_syn_stream(ngx_http_spdy_connection_t *sc, u_char *pos,
     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
                    "spdy SYN_STREAM frame sid:%ui prio:%ui", sid, prio);
 
+    if (sid % 2 == 0 || sid <= sc->last_sid) {
+        ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                      "client sent SYN_STREAM frame "
+                      "with invalid Stream-ID %ui", sid);
+
+        stream = ngx_http_spdy_get_stream_by_id(sc, sid);
+
+        if (stream) {
+            if (ngx_http_spdy_terminate_stream(sc, stream,
+                                               NGX_SPDY_PROTOCOL_ERROR)
+                != NGX_OK)
+            {
+                return ngx_http_spdy_state_internal_error(sc);
+            }
+        }
+
+        return ngx_http_spdy_state_protocol_error(sc);
+    }
+
+    sc->last_sid = sid;
+
     sscf = ngx_http_get_module_srv_conf(sc->http_connection->conf_ctx,
                                         ngx_http_spdy_module);
 
     if (sc->processing >= sscf->concurrent_streams) {
 
         ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
-                      "spdy concurrent streams exceeded %ui", sc->processing);
+                      "concurrent streams exceeded %ui", sc->processing);
 
         if (ngx_http_spdy_send_rst_stream(sc, sid, NGX_SPDY_REFUSED_STREAM,
                                           prio)
@@ -968,8 +1040,6 @@ ngx_http_spdy_state_syn_stream(ngx_http_spdy_connection_t *sc, u_char *pos,
 
     sc->stream = stream;
 
-    sc->last_sid = sid;
-
     return ngx_http_spdy_state_headers(sc, pos, end);
 }
 
@@ -982,7 +1052,6 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
     size_t               size;
     ngx_buf_t           *buf;
     ngx_int_t            rc;
-    ngx_uint_t           complete;
     ngx_http_request_t  *r;
 
     size = end - pos;
@@ -992,18 +1061,14 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
                                         ngx_http_spdy_state_headers);
     }
 
-    if (size >= sc->length) {
+    if (size > sc->length) {
         size = sc->length;
-        complete = 1;
-
-    } else {
-        complete = 0;
     }
 
     r = sc->stream->request;
 
     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                   "spdy process HEADERS %uz of %uz", size, sc->length);
+                   "process spdy header block %uz of %uz", size, sc->length);
 
     buf = r->header_in;
 
@@ -1019,11 +1084,21 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
     if (z == Z_NEED_DICT) {
         z = inflateSetDictionary(&sc->zstream_in, ngx_http_spdy_dict,
                                  sizeof(ngx_http_spdy_dict));
+
         if (z != Z_OK) {
-            ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                          "spdy inflateSetDictionary() failed: %d", z);
-            ngx_http_spdy_close_stream(sc->stream, 0);
-            return ngx_http_spdy_state_protocol_error(sc);
+            if (z == Z_DATA_ERROR) {
+                ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                              "client sent SYN_STREAM frame with header "
+                              "block encoded using wrong dictionary: %ul",
+                              (u_long) sc->zstream_in.adler);
+
+                return ngx_http_spdy_state_protocol_error(sc);
+            }
+
+            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                          "inflateSetDictionary() failed: %d", z);
+
+            return ngx_http_spdy_state_internal_error(sc);
         }
 
         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
@@ -1033,19 +1108,16 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
                                     : Z_OK;
     }
 
-    if (z != Z_OK) {
-        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                      "spdy inflate() failed: %d", z);
-        ngx_http_spdy_close_stream(sc->stream, 0);
-        return ngx_http_spdy_state_protocol_error(sc);
-    }
-
     ngx_log_debug5(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                    "spdy inflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
                    sc->zstream_in.next_in, sc->zstream_in.next_out,
                    sc->zstream_in.avail_in, sc->zstream_in.avail_out,
                    z);
 
+    if (z != Z_OK) {
+        return ngx_http_spdy_state_inflate_error(sc, z);
+    }
+
     sc->length -= sc->zstream_in.next_in - pos;
     pos = sc->zstream_in.next_in;
 
@@ -1055,12 +1127,11 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
 
         if (buf->last - buf->pos < NGX_SPDY_NV_NUM_SIZE) {
 
-            if (complete) {
-                ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                              "client sent SYN_STREAM frame "
-                              "with invalid HEADERS block");
-                ngx_http_spdy_close_stream(sc->stream, NGX_HTTP_BAD_REQUEST);
-                return ngx_http_spdy_state_protocol_error(sc);
+            if (sc->length == 0) {
+                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                               "premature end of spdy header block");
+
+                return ngx_http_spdy_state_headers_error(sc, pos, end);
             }
 
             return ngx_http_spdy_state_save(sc, pos, end,
@@ -1072,7 +1143,7 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
         buf->pos += NGX_SPDY_NV_NUM_SIZE;
 
         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                       "spdy HEADERS block consists of %ui entries",
+                       "spdy header block has %ui entries",
                        sc->entries);
 
         if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
@@ -1081,7 +1152,7 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
         {
             ngx_http_spdy_close_stream(sc->stream,
                                        NGX_HTTP_INTERNAL_SERVER_ERROR);
-            return ngx_http_spdy_state_headers_error(sc, pos, end);
+            return ngx_http_spdy_state_headers_skip(sc, pos, end);
         }
 
         if (ngx_array_init(&r->headers_in.cookies, r->pool, 2,
@@ -1090,7 +1161,7 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
         {
             ngx_http_spdy_close_stream(sc->stream,
                                        NGX_HTTP_INTERNAL_SERVER_ERROR);
-            return ngx_http_spdy_state_headers_error(sc, pos, end);
+            return ngx_http_spdy_state_headers_skip(sc, pos, end);
         }
     }
 
@@ -1113,16 +1184,15 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
                 rc = ngx_http_spdy_alloc_large_header_buffer(r);
 
                 if (rc == NGX_DECLINED) {
-                    /* TODO logging */
                     ngx_http_finalize_request(r,
                                             NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
-                    return ngx_http_spdy_state_headers_error(sc, pos, end);
+                    return ngx_http_spdy_state_headers_skip(sc, pos, end);
                 }
 
                 if (rc != NGX_OK) {
                     ngx_http_spdy_close_stream(sc->stream,
                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
-                    return ngx_http_spdy_state_headers_error(sc, pos, end);
+                    return ngx_http_spdy_state_headers_skip(sc, pos, end);
                 }
 
                 /* null-terminate the last processed header name or value */
@@ -1137,11 +1207,14 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
 
                 z = inflate(&sc->zstream_in, Z_NO_FLUSH);
 
+                ngx_log_debug5(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                           "spdy inflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
+                           sc->zstream_in.next_in, sc->zstream_in.next_out,
+                           sc->zstream_in.avail_in, sc->zstream_in.avail_out,
+                           z);
+
                 if (z != Z_OK) {
-                    ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                                  "spdy inflate() failed: %d", z);
-                    ngx_http_spdy_close_stream(sc->stream, 0);
-                    return ngx_http_spdy_state_protocol_error(sc);
+                    return ngx_http_spdy_state_inflate_error(sc, z);
                 }
 
                 sc->length -= sc->zstream_in.next_in - pos;
@@ -1152,33 +1225,22 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
                 continue;
             }
 
-            if (complete) {
-                /* TODO: improve error message */
+            if (sc->length == 0) {
                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                               "spdy again while last chunk");
-                ngx_http_spdy_close_stream(sc->stream, 0);
-                return ngx_http_spdy_state_protocol_error(sc);
+                               "premature end of spdy header block");
+
+                return ngx_http_spdy_state_headers_error(sc, pos, end);
             }
 
             return ngx_http_spdy_state_save(sc, pos, end,
                                             ngx_http_spdy_state_headers);
 
-        case NGX_HTTP_PARSE_INVALID_REQUEST:
-
-            /* TODO: improve error message */
-            ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                          "client sent invalid header line");
-
+        case NGX_HTTP_PARSE_INVALID_HEADER:
             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
+            return ngx_http_spdy_state_headers_skip(sc, pos, end);
 
+        default: /* NGX_ERROR */
             return ngx_http_spdy_state_headers_error(sc, pos, end);
-
-        default: /* NGX_HTTP_PARSE_INVALID_HEADER */
-
-            ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                          "client sent invalid HEADERS spdy frame");
-            ngx_http_spdy_close_stream(sc->stream, NGX_HTTP_BAD_REQUEST);
-            return ngx_http_spdy_state_protocol_error(sc);
         }
 
         /* a header line has been parsed successfully */
@@ -1187,29 +1249,27 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
 
         if (rc != NGX_OK) {
             if (rc == NGX_HTTP_PARSE_INVALID_HEADER) {
-                ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                              "client sent invalid HEADERS spdy frame");
-                ngx_http_spdy_close_stream(sc->stream, NGX_HTTP_BAD_REQUEST);
-                return ngx_http_spdy_state_protocol_error(sc);
+                ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
+                return ngx_http_spdy_state_headers_skip(sc, pos, end);
             }
 
-            if (rc == NGX_HTTP_PARSE_INVALID_REQUEST) {
-                ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
+            if (rc != NGX_ABORT) {
+                ngx_http_spdy_close_stream(sc->stream,
+                                           NGX_HTTP_INTERNAL_SERVER_ERROR);
             }
 
-            return ngx_http_spdy_state_headers_error(sc, pos, end);
+            return ngx_http_spdy_state_headers_skip(sc, pos, end);
         }
     }
 
     if (buf->pos != buf->last || sc->zstream_in.avail_in) {
-        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                      "client sent SYN_STREAM frame "
-                      "with invalid HEADERS block");
-        ngx_http_spdy_close_stream(sc->stream, NGX_HTTP_BAD_REQUEST);
-        return ngx_http_spdy_state_protocol_error(sc);
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "incorrect number of spdy header block entries");
+
+        return ngx_http_spdy_state_headers_error(sc, pos, end);
     }
 
-    if (!complete) {
+    if (sc->length) {
         return ngx_http_spdy_state_save(sc, pos, end,
                                         ngx_http_spdy_state_headers);
     }
@@ -1223,18 +1283,6 @@ ngx_http_spdy_state_headers(ngx_http_spdy_connection_t *sc, u_char *pos,
 }
 
 
-static u_char *
-ngx_http_spdy_state_headers_error(ngx_http_spdy_connection_t *sc, u_char *pos,
-    u_char *end)
-{
-    if (sc->connection->error) {
-        return ngx_http_spdy_state_internal_error(sc);
-    }
-
-    return ngx_http_spdy_state_headers_skip(sc, pos, end);
-}
-
-
 static u_char *
 ngx_http_spdy_state_headers_skip(ngx_http_spdy_connection_t *sc, u_char *pos,
     u_char *end)
@@ -1254,6 +1302,9 @@ ngx_http_spdy_state_headers_skip(ngx_http_spdy_connection_t *sc, u_char *pos,
                                         ngx_http_spdy_state_headers_skip);
     }
 
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                   "spdy header block skip %uz of %uz", size, sc->length);
+
     sc->zstream_in.next_in = pos;
     sc->zstream_in.avail_in = (size < sc->length) ? size : sc->length;
 
@@ -1263,12 +1314,14 @@ ngx_http_spdy_state_headers_skip(ngx_http_spdy_connection_t *sc, u_char *pos,
 
         n = inflate(&sc->zstream_in, Z_NO_FLUSH);
 
-        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                       "spdy inflate(): %d", n);
+        ngx_log_debug5(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                       "spdy inflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
+                       sc->zstream_in.next_in, sc->zstream_in.next_out,
+                       sc->zstream_in.avail_in, sc->zstream_in.avail_out,
+                       n);
 
         if (n != Z_OK) {
-            /* TODO: logging */
-            return ngx_http_spdy_state_protocol_error(sc);
+            return ngx_http_spdy_state_inflate_error(sc, n);
         }
     }
 
@@ -1284,6 +1337,33 @@ ngx_http_spdy_state_headers_skip(ngx_http_spdy_connection_t *sc, u_char *pos,
 }
 
 
+static u_char *
+ngx_http_spdy_state_headers_error(ngx_http_spdy_connection_t *sc, u_char *pos,
+    u_char *end)
+{
+    ngx_http_spdy_stream_t  *stream;
+
+    stream = sc->stream;
+
+    ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                  "client sent SYN_STREAM frame for stream %ui "
+                  "with invalid header block", stream->id);
+
+    if (ngx_http_spdy_send_rst_stream(sc, stream->id, NGX_SPDY_PROTOCOL_ERROR,
+                                      stream->priority)
+        != NGX_OK)
+    {
+        return ngx_http_spdy_state_internal_error(sc);
+    }
+
+    stream->out_closed = 1;
+
+    ngx_http_spdy_close_stream(stream, NGX_HTTP_BAD_REQUEST);
+
+    return ngx_http_spdy_state_headers_skip(sc, pos, end);
+}
+
+
 static u_char *
 ngx_http_spdy_state_window_update(ngx_http_spdy_connection_t *sc, u_char *pos,
     u_char *end)
@@ -1316,22 +1396,14 @@ ngx_http_spdy_state_window_update(ngx_http_spdy_connection_t *sc, u_char *pos,
     pos += NGX_SPDY_DELTA_SIZE;
 
     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy WINDOW_UPDATE sid:%ui delta:%ui", sid, delta);
+                   "spdy WINDOW_UPDATE sid:%ui delta:%uz", sid, delta);
 
     if (sid) {
         stream = ngx_http_spdy_get_stream_by_id(sc, sid);
 
         if (stream == NULL) {
-            ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
-                          "client sent WINDOW_UPDATE frame "
-                          "for unknown stream %ui", sid);
-
-            if (ngx_http_spdy_send_rst_stream(sc, sid, NGX_SPDY_INVALID_STREAM,
-                                              NGX_SPDY_LOWEST_PRIORITY)
-                == NGX_ERROR)
-            {
-                return ngx_http_spdy_state_internal_error(sc);
-            }
+            ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                           "unknown spdy stream");
 
             return ngx_http_spdy_state_complete(sc, pos, end);
         }
@@ -1341,7 +1413,7 @@ ngx_http_spdy_state_window_update(ngx_http_spdy_connection_t *sc, u_char *pos,
             ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
                           "client violated flow control for stream %ui: "
                           "received WINDOW_UPDATE frame with delta %uz "
-                          "that is not allowed for window %z",
+                          "not allowed for window %z",
                           sid, delta, stream->send_window);
 
             if (ngx_http_spdy_terminate_stream(sc, stream,
@@ -1374,7 +1446,7 @@ ngx_http_spdy_state_window_update(ngx_http_spdy_connection_t *sc, u_char *pos,
             ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
                           "client violated connection flow control: "
                           "received WINDOW_UPDATE frame with delta %uz "
-                          "that is not allowed for window %uz",
+                          "not allowed for window %uz",
                           delta, sc->send_window);
 
             return ngx_http_spdy_state_protocol_error(sc);
@@ -1417,8 +1489,8 @@ ngx_http_spdy_state_data(ngx_http_spdy_connection_t *sc, u_char *pos,
 
     if (sc->length > sc->recv_window) {
         ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
-                      "client violated connection flow control: length of "
-                      "received DATA frame %uz, while available window %uz",
+                      "client violated connection flow control: "
+                      "received DATA frame length %uz, available window %uz",
                       sc->length, sc->recv_window);
 
         return ngx_http_spdy_state_protocol_error(sc);
@@ -1442,13 +1514,16 @@ ngx_http_spdy_state_data(ngx_http_spdy_connection_t *sc, u_char *pos,
     stream = sc->stream;
 
     if (stream == NULL) {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                       "unknown spdy stream");
+
         return ngx_http_spdy_state_skip(sc, pos, end);
     }
 
     if (sc->length > stream->recv_window) {
         ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
-                      "client violated flow control for stream %ui: length of "
-                      "received DATA frame %uz, while available window %uz",
+                      "client violated flow control for stream %ui: "
+                      "received DATA frame length %uz, available window %uz",
                       stream->id, sc->length, stream->recv_window);
 
         if (ngx_http_spdy_terminate_stream(sc, stream,
@@ -1478,7 +1553,7 @@ ngx_http_spdy_state_data(ngx_http_spdy_connection_t *sc, u_char *pos,
 
     if (stream->in_closed) {
         ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
-                      "client sent DATA frame for half closed stream %ui",
+                      "client sent DATA frame for half-closed stream %ui",
                       stream->id);
 
         if (ngx_http_spdy_terminate_stream(sc, stream,
@@ -1521,7 +1596,10 @@ ngx_http_spdy_state_read_data(ngx_http_spdy_connection_t *sc, u_char *pos,
             stream->in_closed = 1;
         }
 
-        /* TODO log and accounting */
+        ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                       "skipping spdy DATA frame, reason: %d",
+                       stream->skip_data);
+
         return ngx_http_spdy_state_skip(sc, pos, end);
     }
 
@@ -1550,7 +1628,10 @@ ngx_http_spdy_state_read_data(ngx_http_spdy_connection_t *sc, u_char *pos,
         if (r->headers_in.content_length_n != -1
             && r->headers_in.content_length_n < rb->rest)
         {
-            /* TODO logging */
+            ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                          "client intended to send body data "
+                          "larger than declared");
+
             stream->skip_data = NGX_SPDY_DATA_ERROR;
             goto error;
 
@@ -1561,9 +1642,8 @@ ngx_http_spdy_state_read_data(ngx_http_spdy_connection_t *sc, u_char *pos,
                 && clcf->client_max_body_size < rb->rest)
             {
                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                              "client intended to send too large chunked "
-                              "body: %O bytes",
-                              rb->rest);
+                              "client intended to send "
+                              "too large chunked body: %O bytes", rb->rest);
 
                 stream->skip_data = NGX_SPDY_DATA_ERROR;
                 goto error;
@@ -1615,7 +1695,7 @@ ngx_http_spdy_state_read_data(ngx_http_spdy_connection_t *sc, u_char *pos,
         } else if (r->headers_in.content_length_n != rb->rest) {
             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
                           "client prematurely closed stream: "
-                          "%O of %O bytes of request body received",
+                          "only %O out of %O bytes of request body received",
                           rb->rest, r->headers_in.content_length_n);
 
             stream->skip_data = NGX_SPDY_DATA_ERROR;
@@ -1694,9 +1774,11 @@ ngx_http_spdy_state_rst_stream(ngx_http_spdy_connection_t *sc, u_char *pos,
                    "spdy RST_STREAM sid:%ui st:%ui", sid, status);
 
     stream = ngx_http_spdy_get_stream_by_id(sc, sid);
+
     if (stream == NULL) {
         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                       "unknown stream, probably it has been closed already");
+                       "unknown spdy stream");
+
         return ngx_http_spdy_state_complete(sc, pos, end);
     }
 
@@ -1715,7 +1797,7 @@ ngx_http_spdy_state_rst_stream(ngx_http_spdy_connection_t *sc, u_char *pos,
 
     case NGX_SPDY_INTERNAL_ERROR:
         ngx_log_error(NGX_LOG_INFO, fc->log, 0,
-                      "client terminated stream %ui because of internal error",
+                      "client terminated stream %ui due to internal error",
                       sid);
         break;
 
@@ -1747,7 +1829,10 @@ ngx_http_spdy_state_ping(ngx_http_spdy_connection_t *sc, u_char *pos,
     }
 
     if (sc->length != NGX_SPDY_PING_SIZE) {
-        /* TODO logging */
+        ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                      "client sent PING frame with incorrect length %uz",
+                      sc->length);
+
         return ngx_http_spdy_state_protocol_error(sc);
     }
 
@@ -1787,6 +1872,9 @@ ngx_http_spdy_state_skip(ngx_http_spdy_connection_t *sc, u_char *pos,
 
     size = end - pos;
 
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                   "spdy frame skip %uz of %uz", size, sc->length);
+
     if (size < sc->length) {
         sc->length -= size;
         return ngx_http_spdy_state_save(sc, end, end,
@@ -1816,13 +1904,16 @@ ngx_http_spdy_state_settings(ngx_http_spdy_connection_t *sc, u_char *pos,
         sc->length -= NGX_SPDY_SETTINGS_NUM_SIZE;
 
         if (sc->length < sc->entries * NGX_SPDY_SETTINGS_PAIR_SIZE) {
-            /* TODO logging */
+            ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                          "client sent SETTINGS frame with incorrect "
+                          "length %uz or number of entries %ui",
+                          sc->length, sc->entries);
+
             return ngx_http_spdy_state_protocol_error(sc);
         }
 
         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                       "spdy SETTINGS frame consists of %ui entries",
-                       sc->entries);
+                       "spdy SETTINGS frame has %ui entries", sc->entries);
     }
 
     while (sc->entries) {
@@ -1882,7 +1973,20 @@ static u_char *
 ngx_http_spdy_state_complete(ngx_http_spdy_connection_t *sc, u_char *pos,
     u_char *end)
 {
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                   "spdy frame complete pos:%p end:%p", pos, end);
+
+    if (pos > end) {
+        ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0,
+                      "receive buffer overrun");
+
+        ngx_debug_point();
+        return ngx_http_spdy_state_internal_error(sc);
+    }
+
     sc->handler = ngx_http_spdy_state_head;
+    sc->stream = NULL;
+
     return pos;
 }
 
@@ -1893,12 +1997,17 @@ ngx_http_spdy_state_save(ngx_http_spdy_connection_t *sc,
 {
     size_t  size;
 
+    ngx_log_debug3(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
+                   "spdy frame state save pos:%p end:%p handler:%p",
+                   pos, end, handler);
+
     size = end - pos;
 
     if (size > NGX_SPDY_STATE_BUFFER_SIZE) {
         ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0,
-                      "spdy state buffer overflow: "
-                      "%uz bytes required", size);
+                      "state buffer overflow: %uz bytes required", size);
+
+        ngx_debug_point();
         return ngx_http_spdy_state_internal_error(sc);
     }
 
@@ -1912,14 +2021,37 @@ ngx_http_spdy_state_save(ngx_http_spdy_connection_t *sc,
 }
 
 
+static u_char *
+ngx_http_spdy_state_inflate_error(ngx_http_spdy_connection_t *sc, int rc)
+{
+    if (rc == Z_DATA_ERROR || rc == Z_STREAM_END) {
+        ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0,
+                      "client sent SYN_STREAM frame with "
+                      "corrupted header block, inflate() failed: %d", rc);
+
+        return ngx_http_spdy_state_protocol_error(sc);
+    }
+
+    ngx_log_error(NGX_LOG_ERR, sc->connection->log, 0,
+                  "inflate() failed: %d", rc);
+
+    return ngx_http_spdy_state_internal_error(sc);
+}
+
+
 static u_char *
 ngx_http_spdy_state_protocol_error(ngx_http_spdy_connection_t *sc)
 {
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
                    "spdy state protocol error");
 
-    /* TODO */
+    if (sc->stream) {
+        sc->stream->out_closed = 1;
+        ngx_http_spdy_close_stream(sc->stream, NGX_HTTP_BAD_REQUEST);
+    }
+
     ngx_http_spdy_finalize_connection(sc, NGX_HTTP_CLIENT_CLOSED_REQUEST);
+
     return NULL;
 }
 
@@ -1930,8 +2062,13 @@ ngx_http_spdy_state_internal_error(ngx_http_spdy_connection_t *sc)
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
                    "spdy state internal error");
 
-    /* TODO */
+    if (sc->stream) {
+        sc->stream->out_closed = 1;
+        ngx_http_spdy_close_stream(sc->stream, NGX_HTTP_INTERNAL_SERVER_ERROR);
+    }
+
     ngx_http_spdy_finalize_connection(sc, NGX_HTTP_INTERNAL_SERVER_ERROR);
+
     return NULL;
 }
 
@@ -1945,7 +2082,7 @@ ngx_http_spdy_send_window_update(ngx_http_spdy_connection_t *sc, ngx_uint_t sid,
     ngx_http_spdy_out_frame_t  *frame;
 
     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy write WINDOW_UPDATE sid:%ui delta:%ui", sid, delta);
+                   "spdy send WINDOW_UPDATE sid:%ui delta:%ui", sid, delta);
 
     frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_WINDOW_UPDATE_SIZE,
                                         NGX_SPDY_HIGHEST_PRIORITY);
@@ -1984,7 +2121,7 @@ ngx_http_spdy_send_rst_stream(ngx_http_spdy_connection_t *sc, ngx_uint_t sid,
     }
 
     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy write RST_STREAM sid:%ui st:%ui", sid, status);
+                   "spdy send RST_STREAM sid:%ui st:%ui", sid, status);
 
     frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_RST_STREAM_SIZE,
                                         priority);
@@ -2019,7 +2156,7 @@ ngx_http_spdy_send_goaway(ngx_http_spdy_connection_t *sc)
     ngx_http_spdy_out_frame_t  *frame;
 
     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy create GOAWAY sid:%ui", sc->last_sid);
+                   "spdy send GOAWAY sid:%ui", sc->last_sid);
 
     frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_GOAWAY_SIZE,
                                         NGX_SPDY_HIGHEST_PRIORITY);
@@ -2055,7 +2192,7 @@ ngx_http_spdy_send_settings(ngx_http_spdy_connection_t *sc)
     ngx_http_spdy_out_frame_t  *frame;
 
     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
-                   "spdy create SETTINGS frame");
+                   "spdy send SETTINGS frame");
 
     frame = ngx_palloc(sc->pool, sizeof(ngx_http_spdy_out_frame_t));
     if (frame == NULL) {
@@ -2177,7 +2314,7 @@ ngx_http_spdy_get_ctl_frame(ngx_http_spdy_connection_t *sc, size_t length,
 #if (NGX_DEBUG)
     if (length > NGX_SPDY_CTL_FRAME_BUFFER_SIZE - NGX_SPDY_FRAME_HEADER_SIZE) {
         ngx_log_error(NGX_LOG_ALERT, sc->pool->log, 0,
-                      "requested control frame is too big: %uz", length);
+                      "requested control frame is too large: %uz", length);
         return NULL;
     }
 
@@ -2395,7 +2532,7 @@ ngx_http_spdy_parse_header(ngx_http_request_t *r)
         r->lowcase_index = ngx_spdy_frame_parse_uint32(p);
 
         if (r->lowcase_index == 0) {
-            return NGX_HTTP_PARSE_INVALID_HEADER;
+            return NGX_ERROR;
         }
 
         /* null-terminate the previous header value */
@@ -2445,11 +2582,15 @@ ngx_http_spdy_parse_header(ngx_http_request_t *r)
             case LF:
             case CR:
             case ':':
-                return NGX_HTTP_PARSE_INVALID_REQUEST;
+                ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                              "client sent invalid header name: \"%*s\"",
+                              r->lowcase_index, r->header_name_start);
+
+                return NGX_HTTP_PARSE_INVALID_HEADER;
             }
 
             if (ch >= 'A' && ch <= 'Z') {
-                return NGX_HTTP_PARSE_INVALID_HEADER;
+                return NGX_ERROR;
             }
 
             r->invalid_header = 1;
@@ -2498,10 +2639,21 @@ ngx_http_spdy_parse_header(ngx_http_request_t *r)
                 r->header_end = p;
                 r->header_in->pos = p + 1;
 
+                r->state = sw_value;
+
                 return NGX_OK;
             }
 
             if (ch == CR || ch == LF) {
+                ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                              "client sent header \"%*s\" with "
+                              "invalid value: \"%*s\\%c...\"",
+                              r->header_name_end - r->header_name_start,
+                              r->header_name_start,
+                              p - r->header_start,
+                              r->header_start,
+                              ch == CR ? 'r' : 'n');
+
                 return NGX_HTTP_PARSE_INVALID_HEADER;
             }
 
@@ -2526,7 +2678,7 @@ ngx_http_spdy_parse_header(ngx_http_request_t *r)
 static ngx_int_t
 ngx_http_spdy_alloc_large_header_buffer(ngx_http_request_t *r)
 {
-    u_char                    *old, *new;
+    u_char                    *old, *new, *p;
     size_t                     rest;
     ngx_buf_t                 *buf;
     ngx_http_spdy_stream_t    *stream;
@@ -2542,12 +2694,29 @@ ngx_http_spdy_alloc_large_header_buffer(ngx_http_request_t *r)
     if (stream->header_buffers
         == (ngx_uint_t) cscf->large_client_header_buffers.num)
     {
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent too large request");
+
         return NGX_DECLINED;
     }
 
     rest = r->header_in->last - r->header_in->pos;
 
-    if (rest >= cscf->large_client_header_buffers.size) {
+    /*
+     * One more byte is needed for null-termination
+     * and another one for further progress.
+     */
+    if (rest > cscf->large_client_header_buffers.size - 2) {
+        p = r->header_in->pos;
+
+        if (rest > NGX_MAX_ERROR_STR - 300) {
+            rest = NGX_MAX_ERROR_STR - 300;
+        }
+
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent too long header name or value: \"%*s...\"",
+                      rest, p);
+
         return NGX_DECLINED;
     }
 
@@ -2557,7 +2726,7 @@ ngx_http_spdy_alloc_large_header_buffer(ngx_http_request_t *r)
     }
 
     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                   "spdy large header alloc: %p %z",
+                   "spdy large header alloc: %p %uz",
                    buf->pos, buf->end - buf->last);
 
     old = r->header_in->pos;
@@ -2612,13 +2781,16 @@ ngx_http_spdy_handle_request_header(ngx_http_request_t *r)
             return sh->handler(r);
         }
 
-        return NGX_HTTP_PARSE_INVALID_REQUEST;
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent invalid header name: \":%*s\"",
+                      r->header_end - r->header_name_start,
+                      r->header_name_start);
+
+        return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
     h = ngx_list_push(&r->headers_in.headers);
     if (h == NULL) {
-        ngx_http_spdy_close_stream(r->spdy_stream,
-                                   NGX_HTTP_INTERNAL_SERVER_ERROR);
         return NGX_ERROR;
     }
 
@@ -2684,6 +2856,9 @@ ngx_http_spdy_parse_method(ngx_http_request_t *r)
     }, *test;
 
     if (r->method_name.len) {
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent duplicate :method header");
+
         return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
@@ -2721,8 +2896,10 @@ ngx_http_spdy_parse_method(ngx_http_request_t *r)
     do {
         if ((*p < 'A' || *p > 'Z') && *p != '_') {
             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
-                          "client sent invalid method");
-            return NGX_HTTP_PARSE_INVALID_REQUEST;
+                          "client sent invalid method: \"%V\"",
+                          &r->method_name);
+
+            return NGX_HTTP_PARSE_INVALID_HEADER;
         }
 
         p++;
@@ -2737,6 +2914,9 @@ static ngx_int_t
 ngx_http_spdy_parse_scheme(ngx_http_request_t *r)
 {
     if (r->schema_start) {
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent duplicate :schema header");
+
         return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
@@ -2753,13 +2933,14 @@ ngx_http_spdy_parse_host(ngx_http_request_t *r)
     ngx_table_elt_t  *h;
 
     if (r->headers_in.host) {
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent duplicate :host header");
+
         return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
     h = ngx_list_push(&r->headers_in.headers);
     if (h == NULL) {
-        ngx_http_spdy_close_stream(r->spdy_stream,
-                                   NGX_HTTP_INTERNAL_SERVER_ERROR);
         return NGX_ERROR;
     }
 
@@ -2783,6 +2964,9 @@ static ngx_int_t
 ngx_http_spdy_parse_path(ngx_http_request_t *r)
 {
     if (r->unparsed_uri.len) {
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent duplicate :path header");
+
         return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
@@ -2790,11 +2974,19 @@ ngx_http_spdy_parse_path(ngx_http_request_t *r)
     r->uri_end = r->header_end;
 
     if (ngx_http_parse_uri(r) != NGX_OK) {
-        return NGX_HTTP_PARSE_INVALID_REQUEST;
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent invalid URI: \"%*s\"",
+                      r->uri_end - r->uri_start, r->uri_start);
+
+        return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
     if (ngx_http_process_request_uri(r) != NGX_OK) {
-        return NGX_ERROR;
+        /*
+         * request has been finalized already
+         * in ngx_http_process_request_uri()
+         */
+        return NGX_ABORT;
     }
 
     return NGX_OK;
@@ -2807,19 +2999,22 @@ ngx_http_spdy_parse_version(ngx_http_request_t *r)
     u_char  *p, ch;
 
     if (r->http_protocol.len) {
+        ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                      "client sent duplicate :version header");
+
         return NGX_HTTP_PARSE_INVALID_HEADER;
     }
 
     p = r->header_start;
 
     if (r->header_end - p < 8 || !(ngx_str5cmp(p, 'H', 'T', 'T', 'P', '/'))) {
-        return NGX_HTTP_PARSE_INVALID_REQUEST;
+        goto invalid;
     }
 
     ch = *(p + 5);
 
     if (ch < '1' || ch > '9') {
-        return NGX_HTTP_PARSE_INVALID_REQUEST;
+        goto invalid;
     }
 
     r->http_major = ch - '0';
@@ -2833,20 +3028,20 @@ ngx_http_spdy_parse_version(ngx_http_request_t *r)
         }
 
         if (ch < '0' || ch > '9') {
-            return NGX_HTTP_PARSE_INVALID_REQUEST;
+            goto invalid;
         }
 
         r->http_major = r->http_major * 10 + ch - '0';
     }
 
     if (*p != '.') {
-        return NGX_HTTP_PARSE_INVALID_REQUEST;
+        goto invalid;
     }
 
     ch = *(p + 1);
 
     if (ch < '0' || ch > '9') {
-        return NGX_HTTP_PARSE_INVALID_REQUEST;
+        goto invalid;
     }
 
     r->http_minor = ch - '0';
@@ -2856,7 +3051,7 @@ ngx_http_spdy_parse_version(ngx_http_request_t *r)
         ch = *p;
 
         if (ch < '0' || ch > '9') {
-            return NGX_HTTP_PARSE_INVALID_REQUEST;
+            goto invalid;
         }
 
         r->http_minor = r->http_minor * 10 + ch - '0';
@@ -2867,6 +3062,14 @@ ngx_http_spdy_parse_version(ngx_http_request_t *r)
     r->http_version = r->http_major * 1000 + r->http_minor;
 
     return NGX_OK;
+
+invalid:
+
+    ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
+                  "client sent invalid http version: \"%*s\"",
+                  r->header_end - r->header_start, r->header_start);
+
+    return NGX_HTTP_PARSE_INVALID_HEADER;
 }
 
 
@@ -2889,7 +3092,8 @@ ngx_http_spdy_construct_request_line(ngx_http_request_t *r)
 
     p = ngx_pnalloc(r->pool, r->request_line.len + 1);
     if (p == NULL) {
-        ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
+        ngx_http_spdy_close_stream(r->spdy_stream,
+                                   NGX_HTTP_INTERNAL_SERVER_ERROR);
         return NGX_ERROR;
     }
 
@@ -2953,7 +3157,7 @@ ngx_http_spdy_run_request(ngx_http_request_t *r)
         }
 
         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
-                       "http header: \"%V: %V\"", &h[i].key, &h[i].value);
+                       "spdy http header: \"%V: %V\"", &h[i].key, &h[i].value);
     }
 
     r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;
@@ -3156,10 +3360,8 @@ ngx_http_spdy_close_stream_handler(ngx_event_t *ev)
 void
 ngx_http_spdy_close_stream(ngx_http_spdy_stream_t *stream, ngx_int_t rc)
 {
-    int                           tcp_nodelay;
     ngx_event_t                  *ev;
-    ngx_connection_t             *c, *fc;
-    ngx_http_core_loc_conf_t     *clcf;
+    ngx_connection_t             *fc;
     ngx_http_spdy_stream_t      **index, *s;
     ngx_http_spdy_srv_conf_t     *sscf;
     ngx_http_spdy_connection_t   *sc;
@@ -3185,54 +3387,6 @@ ngx_http_spdy_close_stream(ngx_http_spdy_stream_t *stream, ngx_int_t rc)
         {
             sc->connection->error = 1;
         }
-
-    } else {
-        c = sc->connection;
-
-        if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
-            if (ngx_tcp_push(c->fd) == -1) {
-                ngx_connection_error(c, ngx_socket_errno,
-                                     ngx_tcp_push_n " failed");
-                c->error = 1;
-                tcp_nodelay = 0;
-
-            } else {
-                c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
-                tcp_nodelay = ngx_tcp_nodelay_and_tcp_nopush ? 1 : 0;
-            }
-
-        } else {
-            tcp_nodelay = 1;
-        }
-
-        clcf = ngx_http_get_module_loc_conf(stream->request,
-                                            ngx_http_core_module);
-
-        if (tcp_nodelay
-            && clcf->tcp_nodelay
-            && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET)
-        {
-            ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");
-
-            if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
-                           (const void *) &tcp_nodelay, sizeof(int))
-                == -1)
-            {
-#if (NGX_SOLARIS)
-                /* Solaris returns EINVAL if a socket has been shut down */
-                c->log_error = NGX_ERROR_IGNORE_EINVAL;
-#endif
-
-                ngx_connection_error(c, ngx_socket_errno,
-                                     "setsockopt(TCP_NODELAY) failed");
-
-                c->log_error = NGX_ERROR_INFO;
-                c->error = 1;
-
-            } else {
-                c->tcp_nodelay = NGX_TCP_NODELAY_SET;
-            }
-        }
     }
 
     if (sc->stream == stream) {
@@ -3265,14 +3419,14 @@ ngx_http_spdy_close_stream(ngx_http_spdy_stream_t *stream, ngx_int_t rc)
 
     if (ev->active || ev->disabled) {
         ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0,
-                      "spdy fake read event was activated");
+                      "fake read event was activated");
     }
 
     if (ev->timer_set) {
         ngx_del_timer(ev);
     }
 
-    if (ev->prev) {
+    if (ev->posted) {
         ngx_delete_posted_event(ev);
     }
 
@@ -3280,14 +3434,14 @@ ngx_http_spdy_close_stream(ngx_http_spdy_stream_t *stream, ngx_int_t rc)
 
     if (ev->active || ev->disabled) {
         ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0,
-                      "spdy fake write event was activated");
+                      "fake write event was activated");
     }
 
     if (ev->timer_set) {
         ngx_del_timer(ev);
     }
 
-    if (ev->prev) {
+    if (ev->posted) {
         ngx_delete_posted_event(ev);
     }