Mercurial > hg > nginx
comparison src/http/ngx_http_event.c @ 89:29bf798b583f
nginx-0.0.1-2003-05-15-19:42:53 import
author | Igor Sysoev <igor@sysoev.ru> |
---|---|
date | Thu, 15 May 2003 15:42:53 +0000 |
parents | 5f6d848dcbef |
children | 637625a2acdb |
comparison
equal
deleted
inserted
replaced
88:674d333f4296 | 89:29bf798b583f |
---|---|
23 static void ngx_http_process_request_headers(ngx_event_t *rev); | 23 static void ngx_http_process_request_headers(ngx_event_t *rev); |
24 static ssize_t ngx_http_read_request_header(ngx_http_request_t *r); | 24 static ssize_t ngx_http_read_request_header(ngx_http_request_t *r); |
25 | 25 |
26 static void ngx_http_writer(ngx_event_t *ev); | 26 static void ngx_http_writer(ngx_event_t *ev); |
27 | 27 |
28 static int ngx_http_block_read(ngx_event_t *ev); | 28 static void ngx_http_block_read(ngx_event_t *ev); |
29 static int ngx_http_read_discarded_body(ngx_event_t *ev); | 29 static void ngx_http_read_discarded_body_event(ngx_event_t *rev); |
30 static int ngx_http_read_discarded_body(ngx_http_request_t *r); | |
30 | 31 |
31 static void ngx_http_set_keepalive(ngx_http_request_t *r); | 32 static void ngx_http_set_keepalive(ngx_http_request_t *r); |
32 static void ngx_http_keepalive_handler(ngx_event_t *ev); | 33 static void ngx_http_keepalive_handler(ngx_event_t *ev); |
33 static void ngx_http_set_lingering_close(ngx_http_request_t *r); | 34 static void ngx_http_set_lingering_close(ngx_http_request_t *r); |
34 static void ngx_http_lingering_close_handler(ngx_event_t *ev); | 35 static void ngx_http_lingering_close_handler(ngx_event_t *ev); |
41 | 42 |
42 static char *header_errors[] = { | 43 static char *header_errors[] = { |
43 "client %s sent invalid method", | 44 "client %s sent invalid method", |
44 "client %s sent invalid request", | 45 "client %s sent invalid request", |
45 "client %s sent too long URI", | 46 "client %s sent too long URI", |
46 "client %s sent HEAD method in HTTP/0.9 request", | 47 "client %s sent invalid method in HTTP/0.9 request", |
47 | 48 |
48 "client %s sent invalid header, URL: %s", | 49 "client %s sent invalid header, URL: %s", |
49 "client %s sent too long header line, URL: %s", | 50 "client %s sent too long header line, URL: %s", |
50 "client %s sent HTTP/1.1 request without \"Host\" header, URL: %s", | 51 "client %s sent HTTP/1.1 request without \"Host\" header, URL: %s", |
51 "client %s sent invalid \"Content-Length\" header, URL: %s" | 52 "client %s sent invalid \"Content-Length\" header, URL: %s" |
336 | 337 |
337 ngx_cpystrn(lcx->url, r->uri_start, r->uri_end - r->uri_start + 1); | 338 ngx_cpystrn(lcx->url, r->uri_start, r->uri_end - r->uri_start + 1); |
338 } | 339 } |
339 | 340 |
340 if (r->http_version == NGX_HTTP_VERSION_9) { | 341 if (r->http_version == NGX_HTTP_VERSION_9) { |
342 if (ngx_http_find_server_conf(r) == NGX_ERROR) { | |
343 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); | |
344 ngx_http_close_connection(c); | |
345 return; | |
346 } | |
347 | |
348 rev->event_handler = ngx_http_block_read; | |
341 ngx_http_handler(r); | 349 ngx_http_handler(r); |
342 return; | 350 return; |
343 } | 351 } |
344 | 352 |
345 lcx->action = "reading client request headers"; | 353 lcx->action = "reading client request headers"; |
537 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); | 545 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST); |
538 return; | 546 return; |
539 } | 547 } |
540 } | 548 } |
541 | 549 |
550 if (ngx_http_find_server_conf(r) == NGX_ERROR) { | |
551 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR); | |
552 ngx_http_close_connection(c); | |
553 return; | |
554 } | |
555 | |
556 rev->event_handler = ngx_http_block_read; | |
542 ngx_http_handler(r); | 557 ngx_http_handler(r); |
543 return; | 558 return; |
544 | 559 |
545 } else if (rc != NGX_AGAIN) { | 560 } else if (rc != NGX_AGAIN) { |
546 | 561 |
603 | 618 |
604 n = ngx_event_recv(r->connection, r->header_in->last, | 619 n = ngx_event_recv(r->connection, r->header_in->last, |
605 r->header_in->end - r->header_in->last); | 620 r->header_in->end - r->header_in->last); |
606 | 621 |
607 if (n == NGX_AGAIN) { | 622 if (n == NGX_AGAIN) { |
623 rev = r->connection->read; | |
624 | |
608 if (!r->header_timeout_set) { | 625 if (!r->header_timeout_set) { |
609 rev = r->connection->read; | |
610 | |
611 if (rev->timer_set) { | 626 if (rev->timer_set) { |
612 ngx_del_timer(rev); | 627 ngx_del_timer(rev); |
613 } else { | 628 } else { |
614 rev->timer_set = 1; | 629 rev->timer_set = 1; |
615 } | 630 } |
664 rc = error; | 679 rc = error; |
665 | 680 |
666 if (rc >= NGX_HTTP_SPECIAL_RESPONSE) { | 681 if (rc >= NGX_HTTP_SPECIAL_RESPONSE) { |
667 | 682 |
668 rev = r->connection->read; | 683 rev = r->connection->read; |
669 | |
670 if (rev->timer_set) { | 684 if (rev->timer_set) { |
671 ngx_del_timer(rev); | 685 ngx_del_timer(rev); |
672 } else { | 686 rev->timer_set = 0; |
673 rev->timer_set = 1; | 687 } |
688 | |
689 wev = r->connection->write; | |
690 if (wev->timer_set) { | |
691 ngx_del_timer(wev); | |
692 wev->timer_set = 0; | |
674 } | 693 } |
675 | 694 |
676 rc = ngx_http_special_response_handler(r, rc); | 695 rc = ngx_http_special_response_handler(r, rc); |
677 } | 696 } |
678 | 697 |
809 if (r->lingering_close) { | 828 if (r->lingering_close) { |
810 ngx_http_set_lingering_close(r); | 829 ngx_http_set_lingering_close(r); |
811 | 830 |
812 } else { | 831 } else { |
813 ngx_http_close_request(r, 0); | 832 ngx_http_close_request(r, 0); |
814 } | 833 ngx_http_close_connection(r->connection); |
815 } | 834 } |
816 | 835 } |
817 | 836 |
818 static int ngx_http_block_read(ngx_event_t *ev) | 837 |
819 { | 838 static void ngx_http_block_read(ngx_event_t *rev) |
820 ngx_log_debug(ev->log, "http read blocked"); | 839 { |
821 | |
822 /* aio does not call this handler */ | |
823 | |
824 #if (USE_KQUEUE) | |
825 | |
826 return NGX_OK; | |
827 | |
828 #else | |
829 | |
830 if (ngx_event_flags & NGX_USE_LEVEL_EVENT) { /* select, poll, /dev/poll */ | |
831 ev->blocked = 1; | |
832 return ngx_del_event(ev, NGX_READ_EVENT, 0); | |
833 | |
834 } else { /* kqueue, epoll */ | |
835 return NGX_OK; | |
836 } | |
837 | |
838 #endif /* USE_KQUEUE */ | |
839 } | |
840 | |
841 | |
842 /* STUB */ | |
843 int ngx_http_discard_body(ngx_http_request_t *r) | |
844 { | |
845 return NGX_OK; | |
846 } | |
847 | |
848 #if 0 | |
849 /* TODO */ | |
850 int ngx_http_discard_body(ngx_http_request_t *r) | |
851 { | |
852 ngx_event_t *ev; | |
853 | |
854 ev = r->connection->read; | |
855 | |
856 ngx_log_debug(r->connection->log, "set discard body"); | |
857 | |
858 if (ev->timer_set) { | |
859 ngx_del_timer(ev); | |
860 ev->timer_set = 0; | |
861 } | |
862 | |
863 if (r->headers_in.content_length_n) { | |
864 ev->event_handler = ngx_http_read_discarded_body; | |
865 /* if blocked - read */ | |
866 /* else add timer */ | |
867 } | |
868 | |
869 return NGX_OK; | |
870 } | |
871 | |
872 | |
873 /* TODO */ | |
874 static int ngx_http_read_discarded_body(ngx_event_t *ev) | |
875 { | |
876 size_t size; | |
877 ssize_t n; | |
878 ngx_connection_t *c; | 840 ngx_connection_t *c; |
879 ngx_http_request_t *r; | 841 ngx_http_request_t *r; |
842 | |
843 ngx_log_debug(rev->log, "http read blocked"); | |
844 | |
845 /* aio does not call this handler */ | |
846 | |
847 if (ngx_event_flags & NGX_USE_LEVEL_EVENT) { | |
848 | |
849 /* select, poll, /dev/poll */ | |
850 | |
851 rev->blocked = 1; | |
852 | |
853 if (ngx_del_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) { | |
854 c = (ngx_connection_t *) rev->data; | |
855 r = (ngx_http_request_t *) c->data; | |
856 ngx_http_close_request(r, 0); | |
857 ngx_http_close_connection(c); | |
858 } | |
859 } | |
860 | |
861 /* kqueue, epoll */ | |
862 | |
863 return; | |
864 } | |
865 | |
866 | |
867 int ngx_http_discard_body(ngx_http_request_t *r) | |
868 { | |
869 ssize_t size; | |
870 ngx_event_t *rev; | |
871 | |
872 rev = r->connection->read; | |
873 | |
874 ngx_log_debug(rev->log, "set discard body"); | |
875 | |
876 if (rev->timer_set) { | |
877 ngx_del_timer(rev); | |
878 rev->timer_set = 0; | |
879 } | |
880 | |
881 if (r->headers_in.content_length_n > 0) { | |
882 | |
883 size = r->header_in->last - r->header_in->pos; | |
884 | |
885 if (size) { | |
886 if (r->headers_in.content_length_n > size) { | |
887 r->headers_in.content_length_n -= size; | |
888 | |
889 } else { | |
890 r->header_in->pos += r->headers_in.content_length_n; | |
891 r->headers_in.content_length_n = 0; | |
892 return NGX_OK; | |
893 } | |
894 } | |
895 | |
896 rev->event_handler = ngx_http_read_discarded_body_event; | |
897 | |
898 if (rev->blocked) { | |
899 if (ngx_event_flags & NGX_USE_LEVEL_EVENT) { | |
900 if (ngx_add_event(rev, NGX_READ_EVENT, NGX_LEVEL_EVENT) | |
901 == NGX_ERROR) { | |
902 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
903 } | |
904 } | |
905 | |
906 rev->blocked = 0; | |
907 return ngx_http_read_discarded_body(r); | |
908 } | |
909 } | |
910 | |
911 return NGX_OK; | |
912 } | |
913 | |
914 | |
915 static void ngx_http_read_discarded_body_event(ngx_event_t *rev) | |
916 { | |
917 int rc; | |
918 ngx_connection_t *c; | |
919 ngx_http_request_t *r; | |
920 | |
921 c = (ngx_connection_t *) rev->data; | |
922 r = (ngx_http_request_t *) c->data; | |
923 | |
924 rc = ngx_http_read_discarded_body(r); | |
925 | |
926 if (rc != NGX_OK) { | |
927 ngx_http_close_request(r, rc); | |
928 ngx_http_close_connection(c); | |
929 } | |
930 } | |
931 | |
932 | |
933 static int ngx_http_read_discarded_body(ngx_http_request_t *r) | |
934 { | |
935 size_t size; | |
936 ssize_t n; | |
880 ngx_http_core_loc_conf_t *lcf; | 937 ngx_http_core_loc_conf_t *lcf; |
881 | 938 |
882 ngx_log_debug(ev->log, "http read discarded body"); | 939 ngx_log_debug(r->connection->log, "http read discarded body"); |
883 | |
884 if (ev->timedout) { | |
885 return NGX_ERROR; | |
886 } | |
887 | |
888 c = (ngx_connection_t *) ev->data; | |
889 r = (ngx_http_request_t *) c->data; | |
890 | 940 |
891 lcf = (ngx_http_core_loc_conf_t *) | 941 lcf = (ngx_http_core_loc_conf_t *) |
892 ngx_http_get_module_loc_conf(r, ngx_http_core_module_ctx); | 942 ngx_http_get_module_loc_conf(r, ngx_http_core_module_ctx); |
893 | 943 |
894 if (r->discarded_buffer == NULL) { | 944 if (r->discarded_buffer == NULL) { |
895 ngx_test_null(r->discarded_buffer, | 945 r->discarded_buffer = ngx_palloc(r->pool, lcf->discarded_buffer_size); |
896 ngx_palloc(r->pool, lcf->discarded_buffer_size), | 946 if (r->discarded_buffer == NULL) { |
897 NGX_ERROR); | 947 return NGX_HTTP_INTERNAL_SERVER_ERROR; |
948 } | |
898 } | 949 } |
899 | 950 |
900 size = r->headers_in.content_length_n; | 951 size = r->headers_in.content_length_n; |
901 if (size > lcf->discarded_buffer_size) { | 952 if (size > lcf->discarded_buffer_size) { |
902 size = lcf->discarded_buffer_size; | 953 size = lcf->discarded_buffer_size; |
903 } | 954 } |
904 | 955 |
905 n = ngx_event_recv(c, r->discarded_buffer, size); | 956 n = ngx_event_recv(r->connection, r->discarded_buffer, size); |
906 if (n == NGX_ERROR) { | 957 if (n == NGX_ERROR) { |
907 return NGX_ERROR; | 958 return NGX_HTTP_BAD_REQUEST; |
908 } | 959 } |
909 | 960 |
910 if (n == NGX_AGAIN) { | 961 if (n == NGX_AGAIN) { |
911 return NGX_OK; | 962 return NGX_OK; |
912 } | 963 } |
913 | 964 |
914 r->headers_in.content_length_n -= n; | 965 r->headers_in.content_length_n -= n; |
915 /* XXX: what if r->client_content_length == 0 ? */ | 966 |
916 return NGX_OK; | 967 return NGX_OK; |
917 } | 968 } |
918 #endif | |
919 | 969 |
920 | 970 |
921 static void ngx_http_set_keepalive(ngx_http_request_t *r) | 971 static void ngx_http_set_keepalive(ngx_http_request_t *r) |
922 { | 972 { |
923 int len, blocked; | 973 int len, blocked; |
1180 | 1230 |
1181 ngx_log_debug(r->connection->log, "close http request"); | 1231 ngx_log_debug(r->connection->log, "close http request"); |
1182 | 1232 |
1183 if (r->pool == NULL) { | 1233 if (r->pool == NULL) { |
1184 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, | 1234 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, |
1185 "http already closed"); | 1235 "http request already closed"); |
1186 return; | 1236 return; |
1187 } | 1237 } |
1188 | 1238 |
1189 if (error) { | 1239 if (error) { |
1190 r->headers_out.status = error; | 1240 r->headers_out.status = error; |