Mercurial > hg > nginx

comparison src/http/ngx_http_event.c @ 89:29bf798b583f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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;