Mercurial > hg > nginx

comparison src/http/ngx_http_event.c @ 24:77c7629a2627

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.1-2002-12-10-21:05:12 import
author Igor Sysoev <igor@sysoev.ru>
date Tue, 10 Dec 2002 18:05:12 +0000
parents f540a63026c9
children 53cb81681040
comparison
equal deleted inserted replaced
23:f540a63026c9 24:77c7629a2627
20 /* STUB */ 20 /* STUB */
21 #include <ngx_http_output_filter.h> 21 #include <ngx_http_output_filter.h>
22 int ngx_http_static_handler(ngx_http_request_t *r); 22 int ngx_http_static_handler(ngx_http_request_t *r);
23 int ngx_http_index_handler(ngx_http_request_t *r); 23 int ngx_http_index_handler(ngx_http_request_t *r);
24 int ngx_http_proxy_handler(ngx_http_request_t *r); 24 int ngx_http_proxy_handler(ngx_http_request_t *r);
25 /* */ 25 /**/
26 26
27 int ngx_http_init_connection(ngx_connection_t *c); 27 int ngx_http_init_connection(ngx_connection_t *c);
28 28
29 static int ngx_http_init_request(ngx_event_t *ev); 29 static int ngx_http_init_request(ngx_event_t *ev);
30 static int ngx_http_process_request(ngx_event_t *ev); 30 static int ngx_http_process_request_header(ngx_event_t *ev);
31 31
32 static int ngx_http_process_request_line(ngx_http_request_t *r); 32 static int ngx_http_process_request_line(ngx_http_request_t *r);
33 static int ngx_http_process_request_header(ngx_http_request_t *r); 33 static int ngx_http_process_request_headers(ngx_http_request_t *r);
34 static int ngx_http_process_request_header_line(ngx_http_request_t *r); 34 static int ngx_http_process_request_header_line(ngx_http_request_t *r);
35 35
36 static int ngx_http_event_handler(ngx_http_request_t *r);
36 static int ngx_http_block_read(ngx_event_t *ev); 37 static int ngx_http_block_read(ngx_event_t *ev);
38
39
37 static int ngx_http_read_discarded_body(ngx_event_t *ev); 40 static int ngx_http_read_discarded_body(ngx_event_t *ev);
38 41
39 static int ngx_http_event_handler(ngx_http_request_t *r); 42 int ngx_http_handler(ngx_http_request_t *r);
40 static int ngx_http_handler(ngx_http_request_t *r);
41 static int ngx_http_set_default_handler(ngx_http_request_t *r); 43 static int ngx_http_set_default_handler(ngx_http_request_t *r);
42 44
43 static int ngx_http_writer(ngx_event_t *ev); 45 static int ngx_http_writer(ngx_event_t *ev);
44 static int ngx_http_set_lingering_close(ngx_http_request_t *r); 46 static int ngx_http_set_lingering_close(ngx_http_request_t *r);
45 static int ngx_http_keepalive_handler(ngx_event_t *ev); 47 static int ngx_http_keepalive_handler(ngx_event_t *ev);
46 static int ngx_http_lingering_close(ngx_event_t *ev); 48 static int ngx_http_lingering_close(ngx_event_t *ev);
47 49
48 static int ngx_http_special_response(ngx_http_request_t *r, int error); 50 #if 0
49 static int ngx_http_redirect(ngx_http_request_t *r, int redirect); 51 int ngx_http_special_response(ngx_http_request_t *r, int error);
50 static int ngx_http_error(ngx_http_request_t *r, int error); 52 int ngx_http_redirect(ngx_http_request_t *r, int redirect);
51 53 int ngx_http_error(ngx_http_request_t *r, int error);
52 static int ngx_http_close_request(ngx_http_request_t *r); 54 int ngx_http_close_request(ngx_http_request_t *r);
55 #endif
56
53 static int ngx_http_close_connection(ngx_event_t *ev); 57 static int ngx_http_close_connection(ngx_event_t *ev);
54 static size_t ngx_http_log_error(void *data, char *buf, size_t len); 58 static size_t ngx_http_log_error(void *data, char *buf, size_t len);
55 59
56 60
57 61
97 101
98 ngx_test_null(addr, ngx_palloc(c->pool, c->socklen), NGX_ERROR); 102 ngx_test_null(addr, ngx_palloc(c->pool, c->socklen), NGX_ERROR);
99 ngx_memcpy(addr, c->sockaddr, c->socklen); 103 ngx_memcpy(addr, c->sockaddr, c->socklen);
100 c->sockaddr = addr; 104 c->sockaddr = addr;
101 105
102 ngx_test_null(c->addr_text, ngx_palloc(c->pool, c->addr_textlen), 106 ngx_test_null(c->addr_text.data, ngx_palloc(c->pool, c->addr_text.len),
103 NGX_ERROR); 107 NGX_ERROR);
108
109 /* STUB: should be ngx_inet_ntop() */
104 #if (WIN32) 110 #if (WIN32)
105 c->addr_text = inet_ntoa((struct in_addr *) 111 c->addr_text.data = inet_ntoa((struct in_addr *)
106 ((char *)c->sockaddr + c->addr)); 112 ((char *)c->sockaddr + c->addr));
107 #else 113 #else
108 inet_ntop(c->family, (char *)c->sockaddr + c->addr, 114 inet_ntop(c->family, (char *)c->sockaddr + c->addr,
109 c->addr_text, c->addr_textlen); 115 c->addr_text.data, c->addr_text.len);
110 #endif 116 #endif
117 /**/
111 118
112 ngx_test_null(ctx, ngx_pcalloc(c->pool, sizeof(ngx_http_log_ctx_t)), 119 ngx_test_null(ctx, ngx_pcalloc(c->pool, sizeof(ngx_http_log_ctx_t)),
113 NGX_ERROR); 120 NGX_ERROR);
114 ctx->client = c->addr_text; 121 ctx->client = c->addr_text.data;
115 ctx->action = "reading client request line"; 122 ctx->action = "reading client request line";
116 c->log->data = ctx; 123 c->log->data = ctx;
117 c->log->handler = ngx_http_log_error; 124 c->log->handler = ngx_http_log_error;
118 125
119 #if (HAVE_DEFERRED_ACCEPT) 126 #if (HAVE_DEFERRED_ACCEPT)
120 if (ev->ready) { 127 if (ev->ready) {
121 return ngx_http_init_request(ev); 128 return ngx_http_init_request(ev);
122 } else { 129 } else {
123 #endif 130 #endif
131 /* STUB: post_accept_timeout should be in http_conf */
124 ngx_add_timer(ev, c->post_accept_timeout); 132 ngx_add_timer(ev, c->post_accept_timeout);
125 #if (USE_KQUEUE) 133 #if (USE_KQUEUE)
126 return ngx_add_event(ev, NGX_READ_EVENT, NGX_CLEAR_EVENT); 134 return ngx_add_event(ev, NGX_READ_EVENT, NGX_CLEAR_EVENT);
127 #else 135 #else
128 #if (HAVE_AIO_EVENT) 136 #if (HAVE_AIO_EVENT)
157 165
158 c->data = r; 166 c->data = r;
159 r->connection = c; 167 r->connection = c;
160 r->server = srv; 168 r->server = srv;
161 169
170 /* STUB */
162 r->srv_conf = ngx_srv_conf; 171 r->srv_conf = ngx_srv_conf;
163 r->loc_conf = ngx_loc_conf; 172 r->loc_conf = ngx_loc_conf;
173 /**/
164 174
165 if (c->buffer == NULL) { 175 if (c->buffer == NULL) {
166 ngx_test_null(c->buffer, 176 ngx_test_null(c->buffer,
167 ngx_create_temp_hunk(c->pool, srv->header_buffer_size, 177 ngx_create_temp_hunk(c->pool, srv->header_buffer_size,
168 0, 0), 178 0, 0),
177 ngx_http_close_request(r)); 187 ngx_http_close_request(r));
178 188
179 ngx_test_null(r->ctx, ngx_pcalloc(r->pool, sizeof(void *) * ngx_max_module), 189 ngx_test_null(r->ctx, ngx_pcalloc(r->pool, sizeof(void *) * ngx_max_module),
180 ngx_http_close_request(r)); 190 ngx_http_close_request(r));
181 191
182 ev->event_handler = ngx_http_process_request; 192 ev->event_handler = ngx_http_process_request_header;
183 r->state_handler = ngx_http_process_request_line; 193 r->state_handler = ngx_http_process_request_line;
184 r->process_header = 1;
185 r->header_timeout = 1; 194 r->header_timeout = 1;
186 195
187 return ngx_http_process_request(ev); 196 return ngx_http_process_request_header(ev);
188 } 197 }
189 198
190 199
191 static int ngx_http_process_request(ngx_event_t *ev) 200 static int ngx_http_process_request_header(ngx_event_t *ev)
192 { 201 {
193 int n, rc; 202 int n, rc;
194 ngx_connection_t *c ; 203 ngx_connection_t *c ;
195 ngx_http_request_t *r; 204 ngx_http_request_t *r;
196 ngx_http_log_ctx_t *ctx; 205 ngx_http_log_ctx_t *ctx;
211 220
212 if (n == NGX_AGAIN) { 221 if (n == NGX_AGAIN) {
213 if (r->header_timeout) { 222 if (r->header_timeout) {
214 r->header_timeout = 0; 223 r->header_timeout = 0;
215 ngx_del_timer(ev); 224 ngx_del_timer(ev);
225 /* STUB: r->server->header_timeout
226 OR r->srv_conf->header_timeout ? */
216 ngx_add_timer(ev, r->server->header_timeout); 227 ngx_add_timer(ev, r->server->header_timeout);
217 } 228 }
218 return NGX_AGAIN; 229 return NGX_AGAIN;
219 } 230 }
220 231
222 return ngx_http_close_request(r); 233 return ngx_http_close_request(r);
223 234
224 ngx_log_debug(ev->log, "http read %d" _ n); 235 ngx_log_debug(ev->log, "http read %d" _ n);
225 236
226 if (n == 0) { 237 if (n == 0) {
227 if (c->unexpected_eof) 238 ngx_log_error(NGX_LOG_INFO, c->log, 0,
228 ngx_log_error(NGX_LOG_INFO, c->log, 0, 239 "client has prematurely closed connection");
229 "client prematurely closed connection");
230 return ngx_http_close_request(r); 240 return ngx_http_close_request(r);
231 } 241 }
232 242
233 r->header_in->last.mem += n; 243 r->header_in->last.mem += n;
234 } 244 }
235 245
236 /* state_handlers are called in following order: 246 /* state_handlers are called in following order:
237 ngx_http_process_request_line(r) 247 ngx_http_process_request_line(r)
238 ngx_http_process_request_header(r) */ 248 ngx_http_process_request_headers(r) */
239 249
240 do { 250 do {
241 rc = (r->state_handler)(r); 251 rc = (r->state_handler)(r);
242 252
243 if (rc == NGX_ERROR) 253 if (rc == NGX_ERROR)
244 return rc; 254 return rc;
245 255
246 /* rc == NGX_OK || rc == NGX_AGAIN */ 256 } while (rc == NGX_AGAIN && r->header_in->pos.mem < r->header_in->last.mem);
247
248 } while (r->process_header
249 && r->header_in->pos.mem < r->header_in->last.mem);
250 257
251 if (r->header_timeout) { 258 if (r->header_timeout) {
252 r->header_timeout = 0; 259 r->header_timeout = 0;
253 ngx_del_timer(ev); 260 ngx_del_timer(ev);
254 ngx_add_timer(ev, r->server->header_timeout); 261 ngx_add_timer(ev, r->server->header_timeout);
255 } 262 }
256 263
257 return rc; 264 if (rc == NGX_OK)
265 return ngx_http_event_handler(r);
266 else
267 return rc;
258 } 268 }
259 269
260 270
261 static int ngx_http_process_request_line(ngx_http_request_t *r) 271 static int ngx_http_process_request_line(ngx_http_request_t *r)
262 { 272 {
268 rc = ngx_read_http_request_line(r); 278 rc = ngx_read_http_request_line(r);
269 279
270 c = r->connection; 280 c = r->connection;
271 281
272 if (rc == NGX_OK) { 282 if (rc == NGX_OK) {
273 len = r->uri_end - r->uri_start + 1; 283 r->uri.len = r->uri_end - r->uri_start;
274 ngx_test_null(r->uri, ngx_palloc(r->pool, len), 284 ngx_test_null(r->uri.data, ngx_palloc(r->pool, r->uri.len + 1),
275 ngx_http_close_request(r)); 285 ngx_http_close_request(r));
276 ngx_cpystrn(r->uri, r->uri_start, len); 286 ngx_cpystrn(r->uri.data, r->uri_start, r->uri.len + 1);
277 287
278 r->request_line.len = r->request_end - r->header_in->start; 288 r->request_line.len = r->request_end - r->header_in->start;
279 ngx_test_null(r->request_line.data, 289 ngx_test_null(r->request_line.data,
280 ngx_palloc(r->pool, r->request_line.len + 1), 290 ngx_palloc(r->pool, r->request_line.len + 1),
281 ngx_http_close_request(r)); 291 ngx_http_close_request(r));
297 307
298 ngx_log_debug(c->log, "REQ: '%s'" _ *request); 308 ngx_log_debug(c->log, "REQ: '%s'" _ *request);
299 /* */ 309 /* */
300 310
301 if (r->uri_ext) { 311 if (r->uri_ext) {
302 ngx_test_null(r->exten, 312 r->exten.len = r->uri_end - r->uri_ext;
303 ngx_palloc(r->pool, r->uri_end - r->uri_ext + 1), 313 ngx_test_null(r->exten.data,
314 ngx_palloc(r->pool, r->exten.len + 1),
304 ngx_http_close_request(r)); 315 ngx_http_close_request(r));
305 ngx_cpystrn(r->exten, r->uri_ext, r->uri_end - r->uri_ext + 1); 316 ngx_cpystrn(r->exten.data, r->uri_ext, r->exten.len + 1);
306 } 317 }
307 318
308 ngx_log_debug(r->connection->log, "HTTP: %d, %d, %s %s" _ 319 ngx_log_debug(r->connection->log, "HTTP: %d, %d, %s %s" _
309 r->method _ r->http_version _ r->uri _ r->exten); 320 r->method _ r->http_version _
321 r->uri.data _ r->exten.data);
310 322
311 if (r->http_version == 9) 323 if (r->http_version == 9)
312 return ngx_http_event_handler(r); 324 return NGX_OK;
313 325
314 /* TODO: check too long URI - no space for header, compact buffer */ 326 /* TODO: check too long URI - no space for header, compact buffer */
315 327
316 r->headers_in.headers = ngx_create_table(r->pool, 10); 328 r->headers_in.headers = ngx_create_table(r->pool, 10);
317 329 /* THINK: when to create out.headers ? */
318 r->state_handler = ngx_http_process_request_header; 330 r->headers_out.headers = ngx_create_table(r->pool, 10);
331
332 r->state_handler = ngx_http_process_request_headers;
319 ctx = r->connection->log->data; 333 ctx = r->connection->log->data;
320 ctx->action = "reading client request headers"; 334 ctx->action = "reading client request headers";
321 335
322 return NGX_OK; 336 return NGX_AGAIN;
323 } 337 }
324 338
325 if (r->header_in->last.mem >= r->header_in->end) { 339 if (r->header_in->last.mem >= r->header_in->end) {
326 rc = NGX_HTTP_PARSE_TOO_LONG_URI; 340 rc = NGX_HTTP_PARSE_TOO_LONG_URI;
327 341
340 NGX_HTTP_REQUEST_URI_TOO_LARGE: 354 NGX_HTTP_REQUEST_URI_TOO_LARGE:
341 NGX_HTTP_BAD_REQUEST); 355 NGX_HTTP_BAD_REQUEST);
342 } 356 }
343 357
344 358
345 static int ngx_http_process_request_header(ngx_http_request_t *r) 359 static int ngx_http_process_request_headers(ngx_http_request_t *r)
346 { 360 {
347 int rc; 361 int rc;
348 ngx_http_log_ctx_t *ctx; 362 ngx_http_log_ctx_t *ctx;
349 363
350 for ( ;; ) { 364 for ( ;; ) {
351 rc = ngx_read_http_header_line(r); 365 rc = ngx_read_http_header_line(r, r->header_in);
352 366
353 /* TODO: check too long header, compact buffer */ 367 /* TODO: check too long header, compact buffer */
354 368
355 if (rc == NGX_OK) { 369 if (rc == NGX_OK) {
356 if (ngx_http_process_request_header_line(r) == NGX_ERROR) 370 if (ngx_http_process_request_header_line(r) == NGX_ERROR)
357 return ngx_http_error(r, NGX_HTTP_BAD_REQUEST); 371 return ngx_http_error(r, NGX_HTTP_BAD_REQUEST);
358 372
359 } else if (rc == NGX_HTTP_PARSE_HEADER_DONE) { 373 } else if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
360 ngx_log_debug(r->connection->log, "HTTP header done"); 374 ngx_log_debug(r->connection->log, "HTTP header done");
361 return ngx_http_event_handler(r); 375 return NGX_OK;
362 376
363 } else if (rc == NGX_AGAIN) { 377 } else if (rc == NGX_AGAIN) {
364 return NGX_AGAIN; 378 return NGX_AGAIN;
365 379
366 } else if (rc == NGX_HTTP_PARSE_INVALID_HEADER) { 380 } else if (rc == NGX_HTTP_PARSE_INVALID_HEADER) {
406 420
407 return NGX_OK; 421 return NGX_OK;
408 } 422 }
409 423
410 424
411 /* ******************** */
412
413 void ngx_http_discard_body(ngx_http_request_t *r)
414 {
415 ngx_log_debug(r->connection->log, "set discard body");
416
417 ngx_del_timer(r->connection->read);
418
419 if (r->client_content_length)
420 r->connection->read->event_handler = ngx_http_read_discarded_body;
421 }
422
423 static int ngx_http_read_discarded_body(ngx_event_t *ev)
424 {
425 size_t size;
426 ssize_t n;
427 ngx_connection_t *c;
428 ngx_http_request_t *r;
429
430 c = (ngx_connection_t *) ev->data;
431 r = (ngx_http_request_t *) c->data;
432
433 ngx_log_debug(ev->log, "http read discarded body");
434
435 if (ev->timedout)
436 return NGX_ERROR;
437
438 if (r->discarded_buffer == NULL)
439 ngx_test_null(r->discarded_buffer,
440 ngx_palloc(r->pool, r->server->discarded_buffer_size),
441 NGX_ERROR);
442
443 size = r->client_content_length;
444 if (size > r->server->discarded_buffer_size)
445 size = r->server->discarded_buffer_size;
446
447 n = ngx_event_recv(c, r->discarded_buffer, size);
448 if (n == NGX_ERROR)
449 return NGX_ERROR;
450
451 if (n == NGX_AGAIN)
452 return NGX_OK;
453
454 r->client_content_length -= n;
455 /* XXX: what if r->client_content_length == 0 ? */
456 return NGX_OK;
457 }
458
459 static int ngx_http_discarded_read(ngx_event_t *ev)
460 {
461 ssize_t n;
462 ngx_connection_t *c;
463 ngx_http_request_t *r;
464
465 c = (ngx_connection_t *) ev->data;
466 r = (ngx_http_request_t *) c->data;
467
468 ngx_log_debug(ev->log, "http discarded read");
469
470 if (ev->timedout)
471 return NGX_ERROR;
472
473 if (r->discarded_buffer == NULL)
474 ngx_test_null(r->discarded_buffer,
475 ngx_palloc(r->pool, r->server->discarded_buffer_size),
476 NGX_ERROR);
477
478 n = ngx_event_recv(c, r->discarded_buffer,
479 r->server->discarded_buffer_size);
480
481 return n;
482 }
483
484 /* ******************** */
485
486
487 static int ngx_http_event_handler(ngx_http_request_t *r) 425 static int ngx_http_event_handler(ngx_http_request_t *r)
488 { 426 {
489 int rc; 427 int rc;
490 ngx_msec_t timeout; 428 ngx_msec_t timeout;
491 429
492 ngx_log_debug(r->connection->log, "UA: '%s: %s'" _ 430 ngx_del_timer(r->connection->read);
493 r->headers_in.user_agent->key.data _ 431 r->header_timeout = 0;
494 r->headers_in.user_agent->value.data); 432
433 r->state_handler = NULL;
434 r->connection->read->event_handler = ngx_http_block_read;
495 435
496 rc = ngx_http_handler(r); 436 rc = ngx_http_handler(r);
497 437
498 /* handler is still busy */ 438 /* handler is still busy */
499 if (rc == NGX_WAITING) 439 if (rc == NGX_WAITING)
551 r->connection->buffer->pos.mem = r->connection->buffer->last.mem 491 r->connection->buffer->pos.mem = r->connection->buffer->last.mem
552 = r->connection->buffer->start; 492 = r->connection->buffer->start;
553 r->connection->read->event_handler = ngx_http_keepalive_handler; 493 r->connection->read->event_handler = ngx_http_keepalive_handler;
554 } 494 }
555 495
556 static int ngx_http_handler(ngx_http_request_t *r) 496
497 static int ngx_http_block_read(ngx_event_t *ev)
498 {
499 ngx_log_debug(ev->log, "http read blocked");
500
501 ev->blocked = 1;
502 return ngx_del_event(ev, NGX_READ_EVENT);
503 }
504
505
506
507 /* FIND PLACE ******************** */
508
509 void ngx_http_discard_body(ngx_http_request_t *r)
510 {
511 ngx_log_debug(r->connection->log, "set discard body");
512
513 ngx_del_timer(r->connection->read);
514
515 if (r->client_content_length)
516 r->connection->read->event_handler = ngx_http_read_discarded_body;
517 }
518
519
520 static int ngx_http_read_discarded_body(ngx_event_t *ev)
521 {
522 size_t size;
523 ssize_t n;
524 ngx_connection_t *c;
525 ngx_http_request_t *r;
526
527 c = (ngx_connection_t *) ev->data;
528 r = (ngx_http_request_t *) c->data;
529
530 ngx_log_debug(ev->log, "http read discarded body");
531
532 if (ev->timedout)
533 return NGX_ERROR;
534
535 if (r->discarded_buffer == NULL)
536 ngx_test_null(r->discarded_buffer,
537 ngx_palloc(r->pool, r->server->discarded_buffer_size),
538 NGX_ERROR);
539
540 size = r->client_content_length;
541 if (size > r->server->discarded_buffer_size)
542 size = r->server->discarded_buffer_size;
543
544 n = ngx_event_recv(c, r->discarded_buffer, size);
545 if (n == NGX_ERROR)
546 return NGX_ERROR;
547
548 if (n == NGX_AGAIN)
549 return NGX_OK;
550
551 r->client_content_length -= n;
552 /* XXX: what if r->client_content_length == 0 ? */
553 return NGX_OK;
554 }
555
556
557 static int ngx_http_discarded_read(ngx_event_t *ev)
558 {
559 ssize_t n;
560 ngx_connection_t *c;
561 ngx_http_request_t *r;
562
563 c = (ngx_connection_t *) ev->data;
564 r = (ngx_http_request_t *) c->data;
565
566 ngx_log_debug(ev->log, "http discarded read");
567
568 if (ev->timedout)
569 return NGX_ERROR;
570
571 if (r->discarded_buffer == NULL)
572 ngx_test_null(r->discarded_buffer,
573 ngx_palloc(r->pool, r->server->discarded_buffer_size),
574 NGX_ERROR);
575
576 n = ngx_event_recv(c, r->discarded_buffer,
577 r->server->discarded_buffer_size);
578
579 return n;
580 }
581
582 /* ******************** */
583
584
585 #if 0
586 int ngx_http_handler(ngx_http_request_t *r)
557 { 587 {
558 int rc; 588 int rc;
559 589
560 ngx_del_timer(r->connection->read);
561 r->header_timeout = 0;
562
563 r->process_header = 0;
564 r->state_handler = NULL;
565 r->connection->unexpected_eof = 0; 590 r->connection->unexpected_eof = 0;
566 r->lingering_close = 1; 591 r->lingering_close = 1;
567 592
568 r->connection->read->event_handler = ngx_http_block_read;
569
570 /* STUB: should find handler */ 593 /* STUB: should find handler */
571 #if 0 594 #if 1
572 r->filter = NGX_HTTP_FILTER_NEED_IN_MEMORY; 595 r->filter = NGX_HTTP_FILTER_NEED_IN_MEMORY;
573 #endif 596 #endif
574 rc = ngx_http_set_default_handler(r); 597 rc = ngx_http_set_default_handler(r);
575 598
576 if (rc >= NGX_HTTP_SPECIAL_RESPONSE) 599 if (rc >= NGX_HTTP_SPECIAL_RESPONSE)
578 601
579 rc = r->handler(r); 602 rc = r->handler(r);
580 603
581 return rc; 604 return rc;
582 } 605 }
583 606 #endif
584 int ngx_http_internal_redirect(ngx_http_request_t *r, char *uri) 607
585 { 608
586 ngx_log_debug(r->connection->log, "internal redirect: '%s'" _ uri); 609 #if 0
587
588 r->uri = uri;
589 r->uri_start = uri;
590 r->uri_end = uri + strlen(uri);
591 return ngx_http_handler(r);
592 }
593
594 static int ngx_http_set_default_handler(ngx_http_request_t *r) 610 static int ngx_http_set_default_handler(ngx_http_request_t *r)
595 { 611 {
596 int err, rc; 612 ngx_err_t err;
597 char *name, *loc, *file; 613 char *name, *loc, *file;
598 614
599 #if 1 615 #if 0
600 /* STUB */ 616 /* STUB */
601 r->handler = ngx_http_proxy_handler; 617 r->handler = ngx_http_proxy_handler;
602 return NGX_OK; 618 return NGX_OK;
603 #endif 619 #endif
604 620
648 664
649 r->handler = ngx_http_static_handler; 665 r->handler = ngx_http_static_handler;
650 666
651 return NGX_OK; 667 return NGX_OK;
652 } 668 }
653 669 #endif
654
655 static int ngx_http_block_read(ngx_event_t *ev)
656 {
657 ngx_log_debug(ev->log, "http read blocked");
658
659 ev->blocked = 1;
660 return ngx_del_event(ev, NGX_READ_EVENT);
661 }
662 670
663 671
664 static int ngx_http_writer(ngx_event_t *ev) 672 static int ngx_http_writer(ngx_event_t *ev)
665 { 673 {
666 int rc; 674 int rc;
723 731
724 ngx_http_close_request(r); 732 ngx_http_close_request(r);
725 c->buffer->pos.mem = c->buffer->last.mem = c->buffer->start; 733 c->buffer->pos.mem = c->buffer->last.mem = c->buffer->start;
726 c->read->event_handler = ngx_http_keepalive_handler; 734 c->read->event_handler = ngx_http_keepalive_handler;
727 } 735 }
736
728 737
729 static int ngx_http_set_lingering_close(ngx_http_request_t *r) 738 static int ngx_http_set_lingering_close(ngx_http_request_t *r)
730 { 739 {
731 r->lingering_time = ngx_time() + r->server->lingering_time; 740 r->lingering_time = ngx_time() + r->server->lingering_time;
732 r->connection->read->event_handler = ngx_http_lingering_close; 741 r->connection->read->event_handler = ngx_http_lingering_close;
840 849
841 return NGX_OK; 850 return NGX_OK;
842 } 851 }
843 852
844 853
845 static int ngx_http_special_response(ngx_http_request_t *r, int error)
846 {
847 return ngx_http_error(r, error);
848 }
849
850
851 static int ngx_http_redirect(ngx_http_request_t *r, int redirect)
852 {
853 /* STUB */
854
855 /* log request */
856
857 return ngx_http_close_request(r);
858 }
859
860
861 static int ngx_http_error(ngx_http_request_t *r, int error)
862 {
863 /* STUB */
864 ngx_log_debug(r->connection->log, "http error: %d" _ error);
865
866 /* log request */
867
868 return ngx_http_close_request(r);
869 }
870
871 #if 0
872
873 static int ngx_process_http_request(ngx_http_request_t *r)
874 {
875 int fd;
876 struct stat sb;
877 ngx_http_header_out_t *header_out;
878 ngx_chunk_t *header, *ch;
879
880 int index = (*(r->uri_end - 1) == '/') ? sizeof(NGX_INDEX) : 1;
881 char *name = ngx_palloc(r->pool,
882 r->uri_end - r->uri_start + strlen(ngx_root) + index);
883 strcpy(name, ngx_root);
884 strcat(name, r->uri_start);
885 if (*(r->uri_end - 1) == '/')
886 strcat(name, NGX_INDEX);
887
888 ngx_log_debug(r->connection->log, "HTTP URI: '%s'", name);
889
890 if ((fd = open(name, O_RDONLY)) == -1) {
891 ngx_log_error(NGX_LOG_ERR, r->connection->log, errno,
892 "open %s failed", name);
893 return -1;
894 }
895
896 if (fstat(fd, &sb) == -1) {
897 ngx_log_error(NGX_LOG_ERR, r->connection->log, errno,
898 "fstat %s failed", name);
899 return -1;
900 }
901
902 header_out = ngx_palloc(r->pool, sizeof(ngx_http_header_out_t));
903
904 header_out->status = NGX_HTTP_OK;
905 header_out->content_length = sb.st_size;
906 header_out->last_modified = sb.st_mtime;
907 header_out->content_type = "text/html";
908 header_out->charset = "koi8-r";
909 header_out->date = time(NULL);
910 header_out->connection = NGX_HTTP_CONN_CLOSE;
911
912 /*
913 header_out->connection = NGX_HTTP_CONN_KEEP_ALIVE;
914 r->connection->read->event_handler = ngx_http_init_request;
915 */
916
917 header = ngx_http_header(r, header_out);
918 ch = ngx_palloc(r->pool, sizeof(ngx_chunk_t));
919 ch->ident = fd;
920 ch->offset = 0;
921 ch->size = sb.st_size;
922 ch->next = NULL;
923 header->next = ch;
924
925 ngx_event_write(r->connection, header);
926
927 return 0;
928 }
929
930 #endif
931
932 static int ngx_http_close_request(ngx_http_request_t *r)
933 {
934 /*
935 if (r->logging)
936 ngx_http_log_request(r);
937 */
938
939 ngx_destroy_pool(r->pool);
940
941 ngx_log_debug(r->connection->log, "http close");
942
943 ngx_del_timer(r->connection->read);
944 ngx_del_timer(r->connection->write);
945
946 return NGX_DONE;
947 }
948
949
950 static int ngx_http_close_connection(ngx_event_t *ev) 854 static int ngx_http_close_connection(ngx_event_t *ev)
951 { 855 {
952 int i, len; 856 int i, len;
953 char **requests, *requests_line, *prev, *new; 857 char **requests, *requests_line, *prev, *new;
954 ngx_connection_t *c = (ngx_connection_t *) ev->data; 858 ngx_connection_t *c = (ngx_connection_t *) ev->data;