Mercurial > hg > nginx-quic
comparison src/http/ngx_http_spdy.c @ 5693:701d6e17e42c
SPDY: improved logging.
author | Valentin Bartenev <vbart@nginx.com> |
---|---|
date | Wed, 30 Apr 2014 20:34:20 +0400 |
parents | ed5fb7d22d46 |
children | 9a95eb9f448b |
comparison
equal
deleted
inserted
replaced
5692:ed5fb7d22d46 | 5693:701d6e17e42c |
---|---|
393 ngx_http_spdy_connection_t *sc; | 393 ngx_http_spdy_connection_t *sc; |
394 | 394 |
395 c = rev->data; | 395 c = rev->data; |
396 hc = c->data; | 396 hc = c->data; |
397 | 397 |
398 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | 398 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "init spdy request"); |
399 "init spdy request"); | |
400 | 399 |
401 c->log->action = "processing SPDY"; | 400 c->log->action = "processing SPDY"; |
402 | 401 |
403 smcf = ngx_http_get_module_main_conf(hc->conf_ctx, ngx_http_spdy_module); | 402 smcf = ngx_http_get_module_main_conf(hc->conf_ctx, ngx_http_spdy_module); |
404 | 403 |
554 break; | 553 break; |
555 } | 554 } |
556 | 555 |
557 if (n == 0 && (sc->incomplete || sc->processing)) { | 556 if (n == 0 && (sc->incomplete || sc->processing)) { |
558 ngx_log_error(NGX_LOG_INFO, c->log, 0, | 557 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
559 "client closed prematurely connection"); | 558 "client prematurely closed connection"); |
560 } | 559 } |
561 | 560 |
562 if (n == 0 || n == NGX_ERROR) { | 561 if (n == 0 || n == NGX_ERROR) { |
563 ngx_http_spdy_finalize_connection(sc, | 562 ngx_http_spdy_finalize_connection(sc, |
564 NGX_HTTP_CLIENT_CLOSED_REQUEST); | 563 NGX_HTTP_CLIENT_CLOSED_REQUEST); |
642 stream = ngx_queue_data(q, ngx_http_spdy_stream_t, queue); | 641 stream = ngx_queue_data(q, ngx_http_spdy_stream_t, queue); |
643 | 642 |
644 stream->handled = 0; | 643 stream->handled = 0; |
645 | 644 |
646 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | 645 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, |
647 "spdy run stream %ui", stream->id); | 646 "run spdy stream %ui", stream->id); |
648 | 647 |
649 wev = stream->request->connection->write; | 648 wev = stream->request->connection->write; |
650 wev->handler(wev); | 649 wev->handler(wev); |
651 } | 650 } |
652 | 651 |
858 sc->length = ngx_spdy_frame_length(flen); | 857 sc->length = ngx_spdy_frame_length(flen); |
859 | 858 |
860 pos += sizeof(uint32_t); | 859 pos += sizeof(uint32_t); |
861 | 860 |
862 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 861 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
863 "spdy process frame head:%08XD f:%Xd l:%uz", | 862 "process spdy frame head:%08XD f:%Xd l:%uz", |
864 head, sc->flags, sc->length); | 863 head, sc->flags, sc->length); |
865 | 864 |
866 if (ngx_spdy_ctl_frame_check(head)) { | 865 if (ngx_spdy_ctl_frame_check(head)) { |
867 type = ngx_spdy_ctl_frame_type(head); | 866 type = ngx_spdy_ctl_frame_type(head); |
868 | 867 |
870 | 869 |
871 case NGX_SPDY_SYN_STREAM: | 870 case NGX_SPDY_SYN_STREAM: |
872 return ngx_http_spdy_state_syn_stream(sc, pos, end); | 871 return ngx_http_spdy_state_syn_stream(sc, pos, end); |
873 | 872 |
874 case NGX_SPDY_SYN_REPLY: | 873 case NGX_SPDY_SYN_REPLY: |
874 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | |
875 "client sent unexpected SYN_REPLY frame"); | |
875 return ngx_http_spdy_state_protocol_error(sc); | 876 return ngx_http_spdy_state_protocol_error(sc); |
876 | 877 |
877 case NGX_SPDY_RST_STREAM: | 878 case NGX_SPDY_RST_STREAM: |
878 return ngx_http_spdy_state_rst_stream(sc, pos, end); | 879 return ngx_http_spdy_state_rst_stream(sc, pos, end); |
879 | 880 |
885 | 886 |
886 case NGX_SPDY_GOAWAY: | 887 case NGX_SPDY_GOAWAY: |
887 return ngx_http_spdy_state_skip(sc, pos, end); /* TODO */ | 888 return ngx_http_spdy_state_skip(sc, pos, end); /* TODO */ |
888 | 889 |
889 case NGX_SPDY_HEADERS: | 890 case NGX_SPDY_HEADERS: |
891 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | |
892 "client sent unexpected HEADERS frame"); | |
890 return ngx_http_spdy_state_protocol_error(sc); | 893 return ngx_http_spdy_state_protocol_error(sc); |
891 | 894 |
892 case NGX_SPDY_WINDOW_UPDATE: | 895 case NGX_SPDY_WINDOW_UPDATE: |
893 return ngx_http_spdy_state_window_update(sc, pos, end); | 896 return ngx_http_spdy_state_window_update(sc, pos, end); |
894 | 897 |
902 if (ngx_spdy_data_frame_check(head)) { | 905 if (ngx_spdy_data_frame_check(head)) { |
903 sc->stream = ngx_http_spdy_get_stream_by_id(sc, head); | 906 sc->stream = ngx_http_spdy_get_stream_by_id(sc, head); |
904 return ngx_http_spdy_state_data(sc, pos, end); | 907 return ngx_http_spdy_state_data(sc, pos, end); |
905 } | 908 } |
906 | 909 |
907 | 910 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
908 /* TODO version & type check */ | 911 "client sent invalid frame"); |
909 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | |
910 "spdy unknown frame"); | |
911 | 912 |
912 return ngx_http_spdy_state_protocol_error(sc); | 913 return ngx_http_spdy_state_protocol_error(sc); |
913 } | 914 } |
914 | 915 |
915 | 916 |
925 return ngx_http_spdy_state_save(sc, pos, end, | 926 return ngx_http_spdy_state_save(sc, pos, end, |
926 ngx_http_spdy_state_syn_stream); | 927 ngx_http_spdy_state_syn_stream); |
927 } | 928 } |
928 | 929 |
929 if (sc->length <= NGX_SPDY_SYN_STREAM_SIZE) { | 930 if (sc->length <= NGX_SPDY_SYN_STREAM_SIZE) { |
930 /* TODO logging */ | 931 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
932 "client sent SYN_STREAM frame with incorrect length %uz", | |
933 sc->length); | |
934 | |
931 return ngx_http_spdy_state_protocol_error(sc); | 935 return ngx_http_spdy_state_protocol_error(sc); |
932 } | 936 } |
933 | 937 |
934 sc->length -= NGX_SPDY_SYN_STREAM_SIZE; | 938 sc->length -= NGX_SPDY_SYN_STREAM_SIZE; |
935 | 939 |
966 ngx_http_spdy_module); | 970 ngx_http_spdy_module); |
967 | 971 |
968 if (sc->processing >= sscf->concurrent_streams) { | 972 if (sc->processing >= sscf->concurrent_streams) { |
969 | 973 |
970 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | 974 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
971 "spdy concurrent streams exceeded %ui", sc->processing); | 975 "concurrent streams exceeded %ui", sc->processing); |
972 | 976 |
973 if (ngx_http_spdy_send_rst_stream(sc, sid, NGX_SPDY_REFUSED_STREAM, | 977 if (ngx_http_spdy_send_rst_stream(sc, sid, NGX_SPDY_REFUSED_STREAM, |
974 prio) | 978 prio) |
975 != NGX_OK) | 979 != NGX_OK) |
976 { | 980 { |
1024 } | 1028 } |
1025 | 1029 |
1026 r = sc->stream->request; | 1030 r = sc->stream->request; |
1027 | 1031 |
1028 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | 1032 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, |
1029 "spdy process HEADERS %uz of %uz", size, sc->length); | 1033 "process spdy header block %uz of %uz", size, sc->length); |
1030 | 1034 |
1031 buf = r->header_in; | 1035 buf = r->header_in; |
1032 | 1036 |
1033 sc->zstream_in.next_in = pos; | 1037 sc->zstream_in.next_in = pos; |
1034 sc->zstream_in.avail_in = size; | 1038 sc->zstream_in.avail_in = size; |
1099 sc->entries = ngx_spdy_frame_parse_uint32(buf->pos); | 1103 sc->entries = ngx_spdy_frame_parse_uint32(buf->pos); |
1100 | 1104 |
1101 buf->pos += NGX_SPDY_NV_NUM_SIZE; | 1105 buf->pos += NGX_SPDY_NV_NUM_SIZE; |
1102 | 1106 |
1103 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | 1107 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, |
1104 "spdy HEADERS block consists of %ui entries", | 1108 "spdy header block has %ui entries", |
1105 sc->entries); | 1109 sc->entries); |
1106 | 1110 |
1107 if (ngx_list_init(&r->headers_in.headers, r->pool, 20, | 1111 if (ngx_list_init(&r->headers_in.headers, r->pool, 20, |
1108 sizeof(ngx_table_elt_t)) | 1112 sizeof(ngx_table_elt_t)) |
1109 != NGX_OK) | 1113 != NGX_OK) |
1140 if (sc->zstream_in.avail_in) { | 1144 if (sc->zstream_in.avail_in) { |
1141 | 1145 |
1142 rc = ngx_http_spdy_alloc_large_header_buffer(r); | 1146 rc = ngx_http_spdy_alloc_large_header_buffer(r); |
1143 | 1147 |
1144 if (rc == NGX_DECLINED) { | 1148 if (rc == NGX_DECLINED) { |
1145 /* TODO logging */ | |
1146 ngx_http_finalize_request(r, | 1149 ngx_http_finalize_request(r, |
1147 NGX_HTTP_REQUEST_HEADER_TOO_LARGE); | 1150 NGX_HTTP_REQUEST_HEADER_TOO_LARGE); |
1148 return ngx_http_spdy_state_headers_skip(sc, pos, end); | 1151 return ngx_http_spdy_state_headers_skip(sc, pos, end); |
1149 } | 1152 } |
1150 | 1153 |
1177 | 1180 |
1178 continue; | 1181 continue; |
1179 } | 1182 } |
1180 | 1183 |
1181 if (complete) { | 1184 if (complete) { |
1182 /* TODO: improve error message */ | |
1183 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | 1185 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, |
1184 "spdy again while last chunk"); | 1186 "premature end of spdy header block"); |
1185 | 1187 |
1186 return ngx_http_spdy_state_headers_error(sc, pos, end); | 1188 return ngx_http_spdy_state_headers_error(sc, pos, end); |
1187 } | 1189 } |
1188 | 1190 |
1189 return ngx_http_spdy_state_save(sc, pos, end, | 1191 return ngx_http_spdy_state_save(sc, pos, end, |
1190 ngx_http_spdy_state_headers); | 1192 ngx_http_spdy_state_headers); |
1191 | 1193 |
1192 case NGX_HTTP_PARSE_INVALID_HEADER: | 1194 case NGX_HTTP_PARSE_INVALID_HEADER: |
1193 | |
1194 /* TODO: improve error message */ | |
1195 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
1196 "client sent invalid header line"); | |
1197 | |
1198 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); | 1195 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); |
1199 | |
1200 return ngx_http_spdy_state_headers_skip(sc, pos, end); | 1196 return ngx_http_spdy_state_headers_skip(sc, pos, end); |
1201 | 1197 |
1202 default: /* NGX_ERROR */ | 1198 default: /* NGX_ERROR */ |
1203 return ngx_http_spdy_state_headers_error(sc, pos, end); | 1199 return ngx_http_spdy_state_headers_error(sc, pos, end); |
1204 } | 1200 } |
1260 if (size == 0) { | 1256 if (size == 0) { |
1261 return ngx_http_spdy_state_save(sc, pos, end, | 1257 return ngx_http_spdy_state_save(sc, pos, end, |
1262 ngx_http_spdy_state_headers_skip); | 1258 ngx_http_spdy_state_headers_skip); |
1263 } | 1259 } |
1264 | 1260 |
1261 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | |
1262 "spdy header block skip %uz of %uz", size, sc->length); | |
1263 | |
1265 sc->zstream_in.next_in = pos; | 1264 sc->zstream_in.next_in = pos; |
1266 sc->zstream_in.avail_in = (size < sc->length) ? size : sc->length; | 1265 sc->zstream_in.avail_in = (size < sc->length) ? size : sc->length; |
1267 | 1266 |
1268 while (sc->zstream_in.avail_in) { | 1267 while (sc->zstream_in.avail_in) { |
1269 sc->zstream_in.next_out = buffer; | 1268 sc->zstream_in.next_out = buffer; |
1362 if (stream->send_window > (ssize_t) (NGX_SPDY_MAX_WINDOW - delta)) { | 1361 if (stream->send_window > (ssize_t) (NGX_SPDY_MAX_WINDOW - delta)) { |
1363 | 1362 |
1364 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | 1363 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1365 "client violated flow control for stream %ui: " | 1364 "client violated flow control for stream %ui: " |
1366 "received WINDOW_UPDATE frame with delta %uz " | 1365 "received WINDOW_UPDATE frame with delta %uz " |
1367 "that is not allowed for window %z", | 1366 "not allowed for window %z", |
1368 sid, delta, stream->send_window); | 1367 sid, delta, stream->send_window); |
1369 | 1368 |
1370 if (ngx_http_spdy_terminate_stream(sc, stream, | 1369 if (ngx_http_spdy_terminate_stream(sc, stream, |
1371 NGX_SPDY_FLOW_CONTROL_ERROR) | 1370 NGX_SPDY_FLOW_CONTROL_ERROR) |
1372 == NGX_ERROR) | 1371 == NGX_ERROR) |
1395 | 1394 |
1396 if (sc->send_window > NGX_SPDY_MAX_WINDOW) { | 1395 if (sc->send_window > NGX_SPDY_MAX_WINDOW) { |
1397 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | 1396 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1398 "client violated connection flow control: " | 1397 "client violated connection flow control: " |
1399 "received WINDOW_UPDATE frame with delta %uz " | 1398 "received WINDOW_UPDATE frame with delta %uz " |
1400 "that is not allowed for window %uz", | 1399 "not allowed for window %uz", |
1401 delta, sc->send_window); | 1400 delta, sc->send_window); |
1402 | 1401 |
1403 return ngx_http_spdy_state_protocol_error(sc); | 1402 return ngx_http_spdy_state_protocol_error(sc); |
1404 } | 1403 } |
1405 | 1404 |
1438 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 1437 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
1439 "spdy DATA frame"); | 1438 "spdy DATA frame"); |
1440 | 1439 |
1441 if (sc->length > sc->recv_window) { | 1440 if (sc->length > sc->recv_window) { |
1442 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | 1441 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1443 "client violated connection flow control: length of " | 1442 "client violated connection flow control: " |
1444 "received DATA frame %uz, while available window %uz", | 1443 "received DATA frame length %uz, available window %uz", |
1445 sc->length, sc->recv_window); | 1444 sc->length, sc->recv_window); |
1446 | 1445 |
1447 return ngx_http_spdy_state_protocol_error(sc); | 1446 return ngx_http_spdy_state_protocol_error(sc); |
1448 } | 1447 } |
1449 | 1448 |
1463 } | 1462 } |
1464 | 1463 |
1465 stream = sc->stream; | 1464 stream = sc->stream; |
1466 | 1465 |
1467 if (stream == NULL) { | 1466 if (stream == NULL) { |
1467 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | |
1468 "unknown spdy stream"); | |
1469 | |
1468 return ngx_http_spdy_state_skip(sc, pos, end); | 1470 return ngx_http_spdy_state_skip(sc, pos, end); |
1469 } | 1471 } |
1470 | 1472 |
1471 if (sc->length > stream->recv_window) { | 1473 if (sc->length > stream->recv_window) { |
1472 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | 1474 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1473 "client violated flow control for stream %ui: length of " | 1475 "client violated flow control for stream %ui: " |
1474 "received DATA frame %uz, while available window %uz", | 1476 "received DATA frame length %uz, available window %uz", |
1475 stream->id, sc->length, stream->recv_window); | 1477 stream->id, sc->length, stream->recv_window); |
1476 | 1478 |
1477 if (ngx_http_spdy_terminate_stream(sc, stream, | 1479 if (ngx_http_spdy_terminate_stream(sc, stream, |
1478 NGX_SPDY_FLOW_CONTROL_ERROR) | 1480 NGX_SPDY_FLOW_CONTROL_ERROR) |
1479 == NGX_ERROR) | 1481 == NGX_ERROR) |
1499 stream->recv_window = NGX_SPDY_STREAM_WINDOW; | 1501 stream->recv_window = NGX_SPDY_STREAM_WINDOW; |
1500 } | 1502 } |
1501 | 1503 |
1502 if (stream->in_closed) { | 1504 if (stream->in_closed) { |
1503 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, | 1505 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1504 "client sent DATA frame for half closed stream %ui", | 1506 "client sent DATA frame for half-closed stream %ui", |
1505 stream->id); | 1507 stream->id); |
1506 | 1508 |
1507 if (ngx_http_spdy_terminate_stream(sc, stream, | 1509 if (ngx_http_spdy_terminate_stream(sc, stream, |
1508 NGX_SPDY_STREAM_ALREADY_CLOSED) | 1510 NGX_SPDY_STREAM_ALREADY_CLOSED) |
1509 == NGX_ERROR) | 1511 == NGX_ERROR) |
1542 | 1544 |
1543 if (sc->flags & NGX_SPDY_FLAG_FIN) { | 1545 if (sc->flags & NGX_SPDY_FLAG_FIN) { |
1544 stream->in_closed = 1; | 1546 stream->in_closed = 1; |
1545 } | 1547 } |
1546 | 1548 |
1547 /* TODO log and accounting */ | 1549 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
1550 "skipping spdy DATA frame, reason: %d", | |
1551 stream->skip_data); | |
1552 | |
1548 return ngx_http_spdy_state_skip(sc, pos, end); | 1553 return ngx_http_spdy_state_skip(sc, pos, end); |
1549 } | 1554 } |
1550 | 1555 |
1551 size = end - pos; | 1556 size = end - pos; |
1552 | 1557 |
1571 rb->rest += size; | 1576 rb->rest += size; |
1572 | 1577 |
1573 if (r->headers_in.content_length_n != -1 | 1578 if (r->headers_in.content_length_n != -1 |
1574 && r->headers_in.content_length_n < rb->rest) | 1579 && r->headers_in.content_length_n < rb->rest) |
1575 { | 1580 { |
1576 /* TODO logging */ | 1581 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, |
1582 "client intended to send body data " | |
1583 "larger than declared"); | |
1584 | |
1577 stream->skip_data = NGX_SPDY_DATA_ERROR; | 1585 stream->skip_data = NGX_SPDY_DATA_ERROR; |
1578 goto error; | 1586 goto error; |
1579 | 1587 |
1580 } else { | 1588 } else { |
1581 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module); | 1589 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module); |
1582 | 1590 |
1583 if (clcf->client_max_body_size | 1591 if (clcf->client_max_body_size |
1584 && clcf->client_max_body_size < rb->rest) | 1592 && clcf->client_max_body_size < rb->rest) |
1585 { | 1593 { |
1586 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | 1594 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, |
1587 "client intended to send too large chunked " | 1595 "client intended to send " |
1588 "body: %O bytes", | 1596 "too large chunked body: %O bytes", rb->rest); |
1589 rb->rest); | |
1590 | 1597 |
1591 stream->skip_data = NGX_SPDY_DATA_ERROR; | 1598 stream->skip_data = NGX_SPDY_DATA_ERROR; |
1592 goto error; | 1599 goto error; |
1593 } | 1600 } |
1594 } | 1601 } |
1636 r->headers_in.content_length_n = rb->rest; | 1643 r->headers_in.content_length_n = rb->rest; |
1637 | 1644 |
1638 } else if (r->headers_in.content_length_n != rb->rest) { | 1645 } else if (r->headers_in.content_length_n != rb->rest) { |
1639 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | 1646 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, |
1640 "client prematurely closed stream: " | 1647 "client prematurely closed stream: " |
1641 "%O of %O bytes of request body received", | 1648 "only %O out of %O bytes of request body received", |
1642 rb->rest, r->headers_in.content_length_n); | 1649 rb->rest, r->headers_in.content_length_n); |
1643 | 1650 |
1644 stream->skip_data = NGX_SPDY_DATA_ERROR; | 1651 stream->skip_data = NGX_SPDY_DATA_ERROR; |
1645 goto error; | 1652 goto error; |
1646 } | 1653 } |
1715 | 1722 |
1716 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 1723 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
1717 "spdy RST_STREAM sid:%ui st:%ui", sid, status); | 1724 "spdy RST_STREAM sid:%ui st:%ui", sid, status); |
1718 | 1725 |
1719 stream = ngx_http_spdy_get_stream_by_id(sc, sid); | 1726 stream = ngx_http_spdy_get_stream_by_id(sc, sid); |
1727 | |
1720 if (stream == NULL) { | 1728 if (stream == NULL) { |
1721 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 1729 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
1722 "unknown stream, probably it has been closed already"); | 1730 "unknown spdy stream"); |
1731 | |
1723 return ngx_http_spdy_state_complete(sc, pos, end); | 1732 return ngx_http_spdy_state_complete(sc, pos, end); |
1724 } | 1733 } |
1725 | 1734 |
1726 stream->in_closed = 1; | 1735 stream->in_closed = 1; |
1727 stream->out_closed = 1; | 1736 stream->out_closed = 1; |
1736 "client canceled stream %ui", sid); | 1745 "client canceled stream %ui", sid); |
1737 break; | 1746 break; |
1738 | 1747 |
1739 case NGX_SPDY_INTERNAL_ERROR: | 1748 case NGX_SPDY_INTERNAL_ERROR: |
1740 ngx_log_error(NGX_LOG_INFO, fc->log, 0, | 1749 ngx_log_error(NGX_LOG_INFO, fc->log, 0, |
1741 "client terminated stream %ui because of internal error", | 1750 "client terminated stream %ui due to internal error", |
1742 sid); | 1751 sid); |
1743 break; | 1752 break; |
1744 | 1753 |
1745 default: | 1754 default: |
1746 ngx_log_error(NGX_LOG_INFO, fc->log, 0, | 1755 ngx_log_error(NGX_LOG_INFO, fc->log, 0, |
1768 return ngx_http_spdy_state_save(sc, pos, end, | 1777 return ngx_http_spdy_state_save(sc, pos, end, |
1769 ngx_http_spdy_state_ping); | 1778 ngx_http_spdy_state_ping); |
1770 } | 1779 } |
1771 | 1780 |
1772 if (sc->length != NGX_SPDY_PING_SIZE) { | 1781 if (sc->length != NGX_SPDY_PING_SIZE) { |
1773 /* TODO logging */ | 1782 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1783 "client sent PING frame with incorrect length %uz", | |
1784 sc->length); | |
1785 | |
1774 return ngx_http_spdy_state_protocol_error(sc); | 1786 return ngx_http_spdy_state_protocol_error(sc); |
1775 } | 1787 } |
1776 | 1788 |
1777 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 1789 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
1778 "spdy PING frame"); | 1790 "spdy PING frame"); |
1808 { | 1820 { |
1809 size_t size; | 1821 size_t size; |
1810 | 1822 |
1811 size = end - pos; | 1823 size = end - pos; |
1812 | 1824 |
1825 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | |
1826 "spdy frame skip %uz of %uz", size, sc->length); | |
1827 | |
1813 if (size < sc->length) { | 1828 if (size < sc->length) { |
1814 sc->length -= size; | 1829 sc->length -= size; |
1815 return ngx_http_spdy_state_save(sc, end, end, | 1830 return ngx_http_spdy_state_save(sc, end, end, |
1816 ngx_http_spdy_state_skip); | 1831 ngx_http_spdy_state_skip); |
1817 } | 1832 } |
1837 | 1852 |
1838 pos += NGX_SPDY_SETTINGS_NUM_SIZE; | 1853 pos += NGX_SPDY_SETTINGS_NUM_SIZE; |
1839 sc->length -= NGX_SPDY_SETTINGS_NUM_SIZE; | 1854 sc->length -= NGX_SPDY_SETTINGS_NUM_SIZE; |
1840 | 1855 |
1841 if (sc->length < sc->entries * NGX_SPDY_SETTINGS_PAIR_SIZE) { | 1856 if (sc->length < sc->entries * NGX_SPDY_SETTINGS_PAIR_SIZE) { |
1842 /* TODO logging */ | 1857 ngx_log_error(NGX_LOG_INFO, sc->connection->log, 0, |
1858 "client sent SETTINGS frame with incorrect " | |
1859 "length %uz or number of entries %ui", | |
1860 sc->length, sc->entries); | |
1861 | |
1843 return ngx_http_spdy_state_protocol_error(sc); | 1862 return ngx_http_spdy_state_protocol_error(sc); |
1844 } | 1863 } |
1845 | 1864 |
1846 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 1865 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
1847 "spdy SETTINGS frame consists of %ui entries", | 1866 "spdy SETTINGS frame has %ui entries", sc->entries); |
1848 sc->entries); | |
1849 } | 1867 } |
1850 | 1868 |
1851 while (sc->entries) { | 1869 while (sc->entries) { |
1852 if (end - pos < NGX_SPDY_SETTINGS_PAIR_SIZE) { | 1870 if (end - pos < NGX_SPDY_SETTINGS_PAIR_SIZE) { |
1853 return ngx_http_spdy_state_save(sc, pos, end, | 1871 return ngx_http_spdy_state_save(sc, pos, end, |
1903 | 1921 |
1904 static u_char * | 1922 static u_char * |
1905 ngx_http_spdy_state_complete(ngx_http_spdy_connection_t *sc, u_char *pos, | 1923 ngx_http_spdy_state_complete(ngx_http_spdy_connection_t *sc, u_char *pos, |
1906 u_char *end) | 1924 u_char *end) |
1907 { | 1925 { |
1926 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | |
1927 "spdy frame complete pos:%p end:%p", pos, end); | |
1928 | |
1908 sc->handler = ngx_http_spdy_state_head; | 1929 sc->handler = ngx_http_spdy_state_head; |
1909 sc->stream = NULL; | 1930 sc->stream = NULL; |
1910 | 1931 |
1911 return pos; | 1932 return pos; |
1912 } | 1933 } |
1916 ngx_http_spdy_state_save(ngx_http_spdy_connection_t *sc, | 1937 ngx_http_spdy_state_save(ngx_http_spdy_connection_t *sc, |
1917 u_char *pos, u_char *end, ngx_http_spdy_handler_pt handler) | 1938 u_char *pos, u_char *end, ngx_http_spdy_handler_pt handler) |
1918 { | 1939 { |
1919 size_t size; | 1940 size_t size; |
1920 | 1941 |
1942 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | |
1943 "spdy frame state save pos:%p end:%p handler:%p", | |
1944 pos, end, handler); | |
1945 | |
1921 size = end - pos; | 1946 size = end - pos; |
1922 | 1947 |
1923 if (size > NGX_SPDY_STATE_BUFFER_SIZE) { | 1948 if (size > NGX_SPDY_STATE_BUFFER_SIZE) { |
1924 ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0, | 1949 ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0, |
1925 "spdy state buffer overflow: " | 1950 "state buffer overflow: %uz bytes required", size); |
1926 "%uz bytes required", size); | 1951 |
1927 return ngx_http_spdy_state_internal_error(sc); | 1952 return ngx_http_spdy_state_internal_error(sc); |
1928 } | 1953 } |
1929 | 1954 |
1930 ngx_memcpy(sc->buffer, pos, NGX_SPDY_STATE_BUFFER_SIZE); | 1955 ngx_memcpy(sc->buffer, pos, NGX_SPDY_STATE_BUFFER_SIZE); |
1931 | 1956 |
1996 u_char *p; | 2021 u_char *p; |
1997 ngx_buf_t *buf; | 2022 ngx_buf_t *buf; |
1998 ngx_http_spdy_out_frame_t *frame; | 2023 ngx_http_spdy_out_frame_t *frame; |
1999 | 2024 |
2000 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 2025 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
2001 "spdy write WINDOW_UPDATE sid:%ui delta:%ui", sid, delta); | 2026 "spdy send WINDOW_UPDATE sid:%ui delta:%ui", sid, delta); |
2002 | 2027 |
2003 frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_WINDOW_UPDATE_SIZE, | 2028 frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_WINDOW_UPDATE_SIZE, |
2004 NGX_SPDY_HIGHEST_PRIORITY); | 2029 NGX_SPDY_HIGHEST_PRIORITY); |
2005 if (frame == NULL) { | 2030 if (frame == NULL) { |
2006 return NGX_ERROR; | 2031 return NGX_ERROR; |
2035 if (sc->connection->error) { | 2060 if (sc->connection->error) { |
2036 return NGX_OK; | 2061 return NGX_OK; |
2037 } | 2062 } |
2038 | 2063 |
2039 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 2064 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
2040 "spdy write RST_STREAM sid:%ui st:%ui", sid, status); | 2065 "spdy send RST_STREAM sid:%ui st:%ui", sid, status); |
2041 | 2066 |
2042 frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_RST_STREAM_SIZE, | 2067 frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_RST_STREAM_SIZE, |
2043 priority); | 2068 priority); |
2044 if (frame == NULL) { | 2069 if (frame == NULL) { |
2045 return NGX_ERROR; | 2070 return NGX_ERROR; |
2070 u_char *p; | 2095 u_char *p; |
2071 ngx_buf_t *buf; | 2096 ngx_buf_t *buf; |
2072 ngx_http_spdy_out_frame_t *frame; | 2097 ngx_http_spdy_out_frame_t *frame; |
2073 | 2098 |
2074 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 2099 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
2075 "spdy create GOAWAY sid:%ui", sc->last_sid); | 2100 "spdy send GOAWAY sid:%ui", sc->last_sid); |
2076 | 2101 |
2077 frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_GOAWAY_SIZE, | 2102 frame = ngx_http_spdy_get_ctl_frame(sc, NGX_SPDY_GOAWAY_SIZE, |
2078 NGX_SPDY_HIGHEST_PRIORITY); | 2103 NGX_SPDY_HIGHEST_PRIORITY); |
2079 if (frame == NULL) { | 2104 if (frame == NULL) { |
2080 return NGX_ERROR; | 2105 return NGX_ERROR; |
2106 ngx_chain_t *cl; | 2131 ngx_chain_t *cl; |
2107 ngx_http_spdy_srv_conf_t *sscf; | 2132 ngx_http_spdy_srv_conf_t *sscf; |
2108 ngx_http_spdy_out_frame_t *frame; | 2133 ngx_http_spdy_out_frame_t *frame; |
2109 | 2134 |
2110 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, | 2135 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0, |
2111 "spdy create SETTINGS frame"); | 2136 "spdy send SETTINGS frame"); |
2112 | 2137 |
2113 frame = ngx_palloc(sc->pool, sizeof(ngx_http_spdy_out_frame_t)); | 2138 frame = ngx_palloc(sc->pool, sizeof(ngx_http_spdy_out_frame_t)); |
2114 if (frame == NULL) { | 2139 if (frame == NULL) { |
2115 return NGX_ERROR; | 2140 return NGX_ERROR; |
2116 } | 2141 } |
2228 } | 2253 } |
2229 | 2254 |
2230 #if (NGX_DEBUG) | 2255 #if (NGX_DEBUG) |
2231 if (length > NGX_SPDY_CTL_FRAME_BUFFER_SIZE - NGX_SPDY_FRAME_HEADER_SIZE) { | 2256 if (length > NGX_SPDY_CTL_FRAME_BUFFER_SIZE - NGX_SPDY_FRAME_HEADER_SIZE) { |
2232 ngx_log_error(NGX_LOG_ALERT, sc->pool->log, 0, | 2257 ngx_log_error(NGX_LOG_ALERT, sc->pool->log, 0, |
2233 "requested control frame is too big: %uz", length); | 2258 "requested control frame is too large: %uz", length); |
2234 return NULL; | 2259 return NULL; |
2235 } | 2260 } |
2236 | 2261 |
2237 frame->length = length; | 2262 frame->length = length; |
2238 #endif | 2263 #endif |
2496 switch (ch) { | 2521 switch (ch) { |
2497 case '\0': | 2522 case '\0': |
2498 case LF: | 2523 case LF: |
2499 case CR: | 2524 case CR: |
2500 case ':': | 2525 case ':': |
2526 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2527 "client sent invalid header name: \"%*s\"", | |
2528 r->lowcase_index, r->header_name_start); | |
2529 | |
2501 return NGX_HTTP_PARSE_INVALID_HEADER; | 2530 return NGX_HTTP_PARSE_INVALID_HEADER; |
2502 } | 2531 } |
2503 | 2532 |
2504 if (ch >= 'A' && ch <= 'Z') { | 2533 if (ch >= 'A' && ch <= 'Z') { |
2505 return NGX_ERROR; | 2534 return NGX_ERROR; |
2553 | 2582 |
2554 return NGX_OK; | 2583 return NGX_OK; |
2555 } | 2584 } |
2556 | 2585 |
2557 if (ch == CR || ch == LF) { | 2586 if (ch == CR || ch == LF) { |
2587 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2588 "client sent header \"%*s\" with " | |
2589 "invalid value: \"%*s\\%c...\"", | |
2590 r->header_name_end - r->header_name_start, | |
2591 r->header_name_start, | |
2592 p - r->header_start, | |
2593 r->header_start, | |
2594 ch == CR ? 'r' : 'n'); | |
2595 | |
2558 return NGX_HTTP_PARSE_INVALID_HEADER; | 2596 return NGX_HTTP_PARSE_INVALID_HEADER; |
2559 } | 2597 } |
2560 | 2598 |
2561 p++; | 2599 p++; |
2562 } | 2600 } |
2577 | 2615 |
2578 | 2616 |
2579 static ngx_int_t | 2617 static ngx_int_t |
2580 ngx_http_spdy_alloc_large_header_buffer(ngx_http_request_t *r) | 2618 ngx_http_spdy_alloc_large_header_buffer(ngx_http_request_t *r) |
2581 { | 2619 { |
2582 u_char *old, *new; | 2620 u_char *old, *new, *p; |
2583 size_t rest; | 2621 size_t rest; |
2584 ngx_buf_t *buf; | 2622 ngx_buf_t *buf; |
2585 ngx_http_spdy_stream_t *stream; | 2623 ngx_http_spdy_stream_t *stream; |
2586 ngx_http_core_srv_conf_t *cscf; | 2624 ngx_http_core_srv_conf_t *cscf; |
2587 | 2625 |
2593 cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module); | 2631 cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module); |
2594 | 2632 |
2595 if (stream->header_buffers | 2633 if (stream->header_buffers |
2596 == (ngx_uint_t) cscf->large_client_header_buffers.num) | 2634 == (ngx_uint_t) cscf->large_client_header_buffers.num) |
2597 { | 2635 { |
2636 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2637 "client sent too large request"); | |
2638 | |
2598 return NGX_DECLINED; | 2639 return NGX_DECLINED; |
2599 } | 2640 } |
2600 | 2641 |
2601 rest = r->header_in->last - r->header_in->pos; | 2642 rest = r->header_in->last - r->header_in->pos; |
2602 | 2643 |
2644 /* | |
2645 * equality is prohibited since one more byte is needed | |
2646 * for null-termination | |
2647 */ | |
2603 if (rest >= cscf->large_client_header_buffers.size) { | 2648 if (rest >= cscf->large_client_header_buffers.size) { |
2649 p = r->header_in->pos; | |
2650 | |
2651 if (rest > NGX_MAX_ERROR_STR - 300) { | |
2652 rest = NGX_MAX_ERROR_STR - 300; | |
2653 p[rest++] = '.'; p[rest++] = '.'; p[rest++] = '.'; | |
2654 } | |
2655 | |
2656 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2657 "client sent too long header name or value: \"%*s\"", | |
2658 rest, p); | |
2659 | |
2604 return NGX_DECLINED; | 2660 return NGX_DECLINED; |
2605 } | 2661 } |
2606 | 2662 |
2607 buf = ngx_create_temp_buf(r->pool, cscf->large_client_header_buffers.size); | 2663 buf = ngx_create_temp_buf(r->pool, cscf->large_client_header_buffers.size); |
2608 if (buf == NULL) { | 2664 if (buf == NULL) { |
2609 return NGX_ERROR; | 2665 return NGX_ERROR; |
2610 } | 2666 } |
2611 | 2667 |
2612 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | 2668 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, |
2613 "spdy large header alloc: %p %z", | 2669 "spdy large header alloc: %p %uz", |
2614 buf->pos, buf->end - buf->last); | 2670 buf->pos, buf->end - buf->last); |
2615 | 2671 |
2616 old = r->header_in->pos; | 2672 old = r->header_in->pos; |
2617 new = buf->pos; | 2673 new = buf->pos; |
2618 | 2674 |
2662 continue; | 2718 continue; |
2663 } | 2719 } |
2664 | 2720 |
2665 return sh->handler(r); | 2721 return sh->handler(r); |
2666 } | 2722 } |
2723 | |
2724 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2725 "client sent invalid header name: \":%*s\"", | |
2726 r->header_end - r->header_name_start, | |
2727 r->header_name_start); | |
2667 | 2728 |
2668 return NGX_HTTP_PARSE_INVALID_HEADER; | 2729 return NGX_HTTP_PARSE_INVALID_HEADER; |
2669 } | 2730 } |
2670 | 2731 |
2671 h = ngx_list_push(&r->headers_in.headers); | 2732 h = ngx_list_push(&r->headers_in.headers); |
2733 { 5, "PATCH", NGX_HTTP_PATCH }, | 2794 { 5, "PATCH", NGX_HTTP_PATCH }, |
2734 { 5, "TRACE", NGX_HTTP_TRACE } | 2795 { 5, "TRACE", NGX_HTTP_TRACE } |
2735 }, *test; | 2796 }, *test; |
2736 | 2797 |
2737 if (r->method_name.len) { | 2798 if (r->method_name.len) { |
2799 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2800 "client sent duplicate :method header"); | |
2801 | |
2738 return NGX_HTTP_PARSE_INVALID_HEADER; | 2802 return NGX_HTTP_PARSE_INVALID_HEADER; |
2739 } | 2803 } |
2740 | 2804 |
2741 len = r->header_end - r->header_start; | 2805 len = r->header_end - r->header_start; |
2742 | 2806 |
2770 p = r->method_name.data; | 2834 p = r->method_name.data; |
2771 | 2835 |
2772 do { | 2836 do { |
2773 if ((*p < 'A' || *p > 'Z') && *p != '_') { | 2837 if ((*p < 'A' || *p > 'Z') && *p != '_') { |
2774 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | 2838 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, |
2775 "client sent invalid method"); | 2839 "client sent invalid method: \"%V\"", |
2840 &r->method_name); | |
2841 | |
2776 return NGX_HTTP_PARSE_INVALID_HEADER; | 2842 return NGX_HTTP_PARSE_INVALID_HEADER; |
2777 } | 2843 } |
2778 | 2844 |
2779 p++; | 2845 p++; |
2780 | 2846 |
2786 | 2852 |
2787 static ngx_int_t | 2853 static ngx_int_t |
2788 ngx_http_spdy_parse_scheme(ngx_http_request_t *r) | 2854 ngx_http_spdy_parse_scheme(ngx_http_request_t *r) |
2789 { | 2855 { |
2790 if (r->schema_start) { | 2856 if (r->schema_start) { |
2857 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2858 "client sent duplicate :schema header"); | |
2859 | |
2791 return NGX_HTTP_PARSE_INVALID_HEADER; | 2860 return NGX_HTTP_PARSE_INVALID_HEADER; |
2792 } | 2861 } |
2793 | 2862 |
2794 r->schema_start = r->header_start; | 2863 r->schema_start = r->header_start; |
2795 r->schema_end = r->header_end; | 2864 r->schema_end = r->header_end; |
2802 ngx_http_spdy_parse_host(ngx_http_request_t *r) | 2871 ngx_http_spdy_parse_host(ngx_http_request_t *r) |
2803 { | 2872 { |
2804 ngx_table_elt_t *h; | 2873 ngx_table_elt_t *h; |
2805 | 2874 |
2806 if (r->headers_in.host) { | 2875 if (r->headers_in.host) { |
2876 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2877 "client sent duplicate :host header"); | |
2878 | |
2807 return NGX_HTTP_PARSE_INVALID_HEADER; | 2879 return NGX_HTTP_PARSE_INVALID_HEADER; |
2808 } | 2880 } |
2809 | 2881 |
2810 h = ngx_list_push(&r->headers_in.headers); | 2882 h = ngx_list_push(&r->headers_in.headers); |
2811 if (h == NULL) { | 2883 if (h == NULL) { |
2830 | 2902 |
2831 static ngx_int_t | 2903 static ngx_int_t |
2832 ngx_http_spdy_parse_path(ngx_http_request_t *r) | 2904 ngx_http_spdy_parse_path(ngx_http_request_t *r) |
2833 { | 2905 { |
2834 if (r->unparsed_uri.len) { | 2906 if (r->unparsed_uri.len) { |
2907 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2908 "client sent duplicate :path header"); | |
2909 | |
2835 return NGX_HTTP_PARSE_INVALID_HEADER; | 2910 return NGX_HTTP_PARSE_INVALID_HEADER; |
2836 } | 2911 } |
2837 | 2912 |
2838 r->uri_start = r->header_start; | 2913 r->uri_start = r->header_start; |
2839 r->uri_end = r->header_end; | 2914 r->uri_end = r->header_end; |
2840 | 2915 |
2841 if (ngx_http_parse_uri(r) != NGX_OK) { | 2916 if (ngx_http_parse_uri(r) != NGX_OK) { |
2917 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2918 "client sent invalid URI: \"%*s\"", | |
2919 r->uri_end - r->uri_start, r->uri_start); | |
2920 | |
2842 return NGX_HTTP_PARSE_INVALID_HEADER; | 2921 return NGX_HTTP_PARSE_INVALID_HEADER; |
2843 } | 2922 } |
2844 | 2923 |
2845 if (ngx_http_process_request_uri(r) != NGX_OK) { | 2924 if (ngx_http_process_request_uri(r) != NGX_OK) { |
2846 /* | 2925 /* |
2858 ngx_http_spdy_parse_version(ngx_http_request_t *r) | 2937 ngx_http_spdy_parse_version(ngx_http_request_t *r) |
2859 { | 2938 { |
2860 u_char *p, ch; | 2939 u_char *p, ch; |
2861 | 2940 |
2862 if (r->http_protocol.len) { | 2941 if (r->http_protocol.len) { |
2942 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
2943 "client sent duplicate :version header"); | |
2944 | |
2863 return NGX_HTTP_PARSE_INVALID_HEADER; | 2945 return NGX_HTTP_PARSE_INVALID_HEADER; |
2864 } | 2946 } |
2865 | 2947 |
2866 p = r->header_start; | 2948 p = r->header_start; |
2867 | 2949 |
2868 if (r->header_end - p < 8 || !(ngx_str5cmp(p, 'H', 'T', 'T', 'P', '/'))) { | 2950 if (r->header_end - p < 8 || !(ngx_str5cmp(p, 'H', 'T', 'T', 'P', '/'))) { |
2869 return NGX_HTTP_PARSE_INVALID_HEADER; | 2951 goto invalid; |
2870 } | 2952 } |
2871 | 2953 |
2872 ch = *(p + 5); | 2954 ch = *(p + 5); |
2873 | 2955 |
2874 if (ch < '1' || ch > '9') { | 2956 if (ch < '1' || ch > '9') { |
2875 return NGX_HTTP_PARSE_INVALID_HEADER; | 2957 goto invalid; |
2876 } | 2958 } |
2877 | 2959 |
2878 r->http_major = ch - '0'; | 2960 r->http_major = ch - '0'; |
2879 | 2961 |
2880 for (p += 6; p != r->header_end - 2; p++) { | 2962 for (p += 6; p != r->header_end - 2; p++) { |
2884 if (ch == '.') { | 2966 if (ch == '.') { |
2885 break; | 2967 break; |
2886 } | 2968 } |
2887 | 2969 |
2888 if (ch < '0' || ch > '9') { | 2970 if (ch < '0' || ch > '9') { |
2889 return NGX_HTTP_PARSE_INVALID_HEADER; | 2971 goto invalid; |
2890 } | 2972 } |
2891 | 2973 |
2892 r->http_major = r->http_major * 10 + ch - '0'; | 2974 r->http_major = r->http_major * 10 + ch - '0'; |
2893 } | 2975 } |
2894 | 2976 |
2895 if (*p != '.') { | 2977 if (*p != '.') { |
2896 return NGX_HTTP_PARSE_INVALID_HEADER; | 2978 goto invalid; |
2897 } | 2979 } |
2898 | 2980 |
2899 ch = *(p + 1); | 2981 ch = *(p + 1); |
2900 | 2982 |
2901 if (ch < '0' || ch > '9') { | 2983 if (ch < '0' || ch > '9') { |
2902 return NGX_HTTP_PARSE_INVALID_HEADER; | 2984 goto invalid; |
2903 } | 2985 } |
2904 | 2986 |
2905 r->http_minor = ch - '0'; | 2987 r->http_minor = ch - '0'; |
2906 | 2988 |
2907 for (p += 2; p != r->header_end; p++) { | 2989 for (p += 2; p != r->header_end; p++) { |
2908 | 2990 |
2909 ch = *p; | 2991 ch = *p; |
2910 | 2992 |
2911 if (ch < '0' || ch > '9') { | 2993 if (ch < '0' || ch > '9') { |
2912 return NGX_HTTP_PARSE_INVALID_HEADER; | 2994 goto invalid; |
2913 } | 2995 } |
2914 | 2996 |
2915 r->http_minor = r->http_minor * 10 + ch - '0'; | 2997 r->http_minor = r->http_minor * 10 + ch - '0'; |
2916 } | 2998 } |
2917 | 2999 |
2918 r->http_protocol.len = r->header_end - r->header_start; | 3000 r->http_protocol.len = r->header_end - r->header_start; |
2919 r->http_protocol.data = r->header_start; | 3001 r->http_protocol.data = r->header_start; |
2920 r->http_version = r->http_major * 1000 + r->http_minor; | 3002 r->http_version = r->http_major * 1000 + r->http_minor; |
2921 | 3003 |
2922 return NGX_OK; | 3004 return NGX_OK; |
3005 | |
3006 invalid: | |
3007 | |
3008 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0, | |
3009 "client sent invalid http version: \"%*s\"", | |
3010 r->header_end - r->header_start, r->header_start); | |
3011 | |
3012 return NGX_HTTP_PARSE_INVALID_HEADER; | |
2923 } | 3013 } |
2924 | 3014 |
2925 | 3015 |
2926 static ngx_int_t | 3016 static ngx_int_t |
2927 ngx_http_spdy_construct_request_line(ngx_http_request_t *r) | 3017 ngx_http_spdy_construct_request_line(ngx_http_request_t *r) |
3005 if (hh && hh->handler(r, &h[i], hh->offset) != NGX_OK) { | 3095 if (hh && hh->handler(r, &h[i], hh->offset) != NGX_OK) { |
3006 return; | 3096 return; |
3007 } | 3097 } |
3008 | 3098 |
3009 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | 3099 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, |
3010 "http header: \"%V: %V\"", &h[i].key, &h[i].value); | 3100 "spdy http header: \"%V: %V\"", &h[i].key, &h[i].value); |
3011 } | 3101 } |
3012 | 3102 |
3013 r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE; | 3103 r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE; |
3014 | 3104 |
3015 if (ngx_http_process_request_header(r) != NGX_OK) { | 3105 if (ngx_http_process_request_header(r) != NGX_OK) { |
3267 | 3357 |
3268 ev = fc->read; | 3358 ev = fc->read; |
3269 | 3359 |
3270 if (ev->active || ev->disabled) { | 3360 if (ev->active || ev->disabled) { |
3271 ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0, | 3361 ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0, |
3272 "spdy fake read event was activated"); | 3362 "fake read event was activated"); |
3273 } | 3363 } |
3274 | 3364 |
3275 if (ev->timer_set) { | 3365 if (ev->timer_set) { |
3276 ngx_del_timer(ev); | 3366 ngx_del_timer(ev); |
3277 } | 3367 } |
3282 | 3372 |
3283 ev = fc->write; | 3373 ev = fc->write; |
3284 | 3374 |
3285 if (ev->active || ev->disabled) { | 3375 if (ev->active || ev->disabled) { |
3286 ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0, | 3376 ngx_log_error(NGX_LOG_ALERT, sc->connection->log, 0, |
3287 "spdy fake write event was activated"); | 3377 "fake write event was activated"); |
3288 } | 3378 } |
3289 | 3379 |
3290 if (ev->timer_set) { | 3380 if (ev->timer_set) { |
3291 ngx_del_timer(ev); | 3381 ngx_del_timer(ev); |
3292 } | 3382 } |