![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_request_body.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http|
Return to ngx_http_request_body.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
8: #include <ngx_config.h>
9: #include <ngx_core.h>
10: #include <ngx_http.h>
11:
12:
13: static void ngx_http_read_client_request_body_handler(ngx_http_request_t *r);
14: static ngx_int_t ngx_http_do_read_client_request_body(ngx_http_request_t *r);
15: static ngx_int_t ngx_http_write_request_body(ngx_http_request_t *r);
16: static ngx_int_t ngx_http_read_discarded_request_body(ngx_http_request_t *r);
17: static ngx_int_t ngx_http_discard_request_body_filter(ngx_http_request_t *r,
18: ngx_buf_t *b);
19: static ngx_int_t ngx_http_test_expect(ngx_http_request_t *r);
20:
21: static ngx_int_t ngx_http_request_body_filter(ngx_http_request_t *r,
22: ngx_chain_t *in);
23: static ngx_int_t ngx_http_request_body_length_filter(ngx_http_request_t *r,
24: ngx_chain_t *in);
25: static ngx_int_t ngx_http_request_body_chunked_filter(ngx_http_request_t *r,
26: ngx_chain_t *in);
27: static ngx_int_t ngx_http_request_body_save_filter(ngx_http_request_t *r,
28: ngx_chain_t *in);
29:
30:
31: ngx_int_t
32: ngx_http_read_client_request_body(ngx_http_request_t *r,
33: ngx_http_client_body_handler_pt post_handler)
34: {
35: size_t preread;
36: ssize_t size;
37: ngx_int_t rc;
38: ngx_buf_t *b;
39: ngx_chain_t out, *cl;
40: ngx_http_request_body_t *rb;
41: ngx_http_core_loc_conf_t *clcf;
42:
43: r->main->count++;
44:
45: #if (NGX_HTTP_SPDY)
46: if (r->spdy_stream) {
47: rc = ngx_http_spdy_read_request_body(r, post_handler);
48: goto done;
49: }
50: #endif
51:
52: if (r != r->main || r->request_body || r->discard_body) {
53: post_handler(r);
54: return NGX_OK;
55: }
56:
57: if (ngx_http_test_expect(r) != NGX_OK) {
58: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
59: goto done;
60: }
61:
62: rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
63: if (rb == NULL) {
64: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
65: goto done;
66: }
67:
68: /*
69: * set by ngx_pcalloc():
70: *
71: * rb->bufs = NULL;
72: * rb->buf = NULL;
73: * rb->free = NULL;
74: * rb->busy = NULL;
75: * rb->chunked = NULL;
76: */
77:
78: rb->rest = -1;
79: rb->post_handler = post_handler;
80:
81: r->request_body = rb;
82:
83: if (r->headers_in.content_length_n < 0 && !r->headers_in.chunked) {
84: post_handler(r);
85: return NGX_OK;
86: }
87:
88: preread = r->header_in->last - r->header_in->pos;
89:
90: if (preread) {
91:
92: /* there is the pre-read part of the request body */
93:
94: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
95: "http client request body preread %uz", preread);
96:
97: out.buf = r->header_in;
98: out.next = NULL;
99:
100: rc = ngx_http_request_body_filter(r, &out);
101:
102: if (rc != NGX_OK) {
103: goto done;
104: }
105:
106: r->request_length += preread - (r->header_in->last - r->header_in->pos);
107:
108: if (!r->headers_in.chunked
109: && rb->rest > 0
110: && rb->rest <= (off_t) (r->header_in->end - r->header_in->last))
111: {
112: /* the whole request body may be placed in r->header_in */
113:
114: b = ngx_calloc_buf(r->pool);
115: if (b == NULL) {
116: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
117: goto done;
118: }
119:
120: b->temporary = 1;
121: b->start = r->header_in->pos;
122: b->pos = r->header_in->pos;
123: b->last = r->header_in->last;
124: b->end = r->header_in->end;
125:
126: rb->buf = b;
127:
128: r->read_event_handler = ngx_http_read_client_request_body_handler;
129: r->write_event_handler = ngx_http_request_empty_handler;
130:
131: rc = ngx_http_do_read_client_request_body(r);
132: goto done;
133: }
134:
135: } else {
136: /* set rb->rest */
137:
138: if (ngx_http_request_body_filter(r, NULL) != NGX_OK) {
139: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
140: goto done;
141: }
142: }
143:
144: if (rb->rest == 0) {
145: /* the whole request body was pre-read */
146:
147: if (r->request_body_in_file_only) {
148: if (ngx_http_write_request_body(r) != NGX_OK) {
149: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
150: goto done;
151: }
152:
153: cl = ngx_chain_get_free_buf(r->pool, &rb->free);
154: if (cl == NULL) {
155: return NGX_HTTP_INTERNAL_SERVER_ERROR;
156: }
157:
158: b = cl->buf;
159:
160: ngx_memzero(b, sizeof(ngx_buf_t));
161:
162: b->in_file = 1;
163: b->file_last = rb->temp_file->file.offset;
164: b->file = &rb->temp_file->file;
165:
166: rb->bufs = cl;
167: }
168:
169: post_handler(r);
170:
171: return NGX_OK;
172: }
173:
174: if (rb->rest < 0) {
175: ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
176: "negative request body rest");
177: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
178: goto done;
179: }
180:
181: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
182:
183: size = clcf->client_body_buffer_size;
184: size += size >> 2;
185:
186: /* TODO: honor r->request_body_in_single_buf */
187:
188: if (!r->headers_in.chunked && rb->rest < size) {
189: size = (ssize_t) rb->rest;
190:
191: if (r->request_body_in_single_buf) {
192: size += preread;
193: }
194:
195: } else {
196: size = clcf->client_body_buffer_size;
197: }
198:
199: rb->buf = ngx_create_temp_buf(r->pool, size);
200: if (rb->buf == NULL) {
201: rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
202: goto done;
203: }
204:
205: r->read_event_handler = ngx_http_read_client_request_body_handler;
206: r->write_event_handler = ngx_http_request_empty_handler;
207:
208: rc = ngx_http_do_read_client_request_body(r);
209:
210: done:
211:
212: if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
213: r->main->count--;
214: }
215:
216: return rc;
217: }
218:
219:
220: static void
221: ngx_http_read_client_request_body_handler(ngx_http_request_t *r)
222: {
223: ngx_int_t rc;
224:
225: if (r->connection->read->timedout) {
226: r->connection->timedout = 1;
227: ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
228: return;
229: }
230:
231: rc = ngx_http_do_read_client_request_body(r);
232:
233: if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
234: ngx_http_finalize_request(r, rc);
235: }
236: }
237:
238:
239: static ngx_int_t
240: ngx_http_do_read_client_request_body(ngx_http_request_t *r)
241: {
242: off_t rest;
243: size_t size;
244: ssize_t n;
245: ngx_int_t rc;
246: ngx_buf_t *b;
247: ngx_chain_t *cl, out;
248: ngx_connection_t *c;
249: ngx_http_request_body_t *rb;
250: ngx_http_core_loc_conf_t *clcf;
251:
252: c = r->connection;
253: rb = r->request_body;
254:
255: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
256: "http read client request body");
257:
258: for ( ;; ) {
259: for ( ;; ) {
260: if (rb->buf->last == rb->buf->end) {
261:
262: /* pass buffer to request body filter chain */
263:
264: out.buf = rb->buf;
265: out.next = NULL;
266:
267: rc = ngx_http_request_body_filter(r, &out);
268:
269: if (rc != NGX_OK) {
270: return rc;
271: }
272:
273: /* write to file */
274:
275: if (ngx_http_write_request_body(r) != NGX_OK) {
276: return NGX_HTTP_INTERNAL_SERVER_ERROR;
277: }
278:
279: /* update chains */
280:
281: rc = ngx_http_request_body_filter(r, NULL);
282:
283: if (rc != NGX_OK) {
284: return rc;
285: }
286:
287: if (rb->busy != NULL) {
288: return NGX_HTTP_INTERNAL_SERVER_ERROR;
289: }
290:
291: rb->buf->pos = rb->buf->start;
292: rb->buf->last = rb->buf->start;
293: }
294:
295: size = rb->buf->end - rb->buf->last;
296: rest = rb->rest - (rb->buf->last - rb->buf->pos);
297:
298: if ((off_t) size > rest) {
299: size = (size_t) rest;
300: }
301:
302: n = c->recv(c, rb->buf->last, size);
303:
304: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
305: "http client request body recv %z", n);
306:
307: if (n == NGX_AGAIN) {
308: break;
309: }
310:
311: if (n == 0) {
312: ngx_log_error(NGX_LOG_INFO, c->log, 0,
313: "client prematurely closed connection");
314: }
315:
316: if (n == 0 || n == NGX_ERROR) {
317: c->error = 1;
318: return NGX_HTTP_BAD_REQUEST;
319: }
320:
321: rb->buf->last += n;
322: r->request_length += n;
323:
324: if (n == rest) {
325: /* pass buffer to request body filter chain */
326:
327: out.buf = rb->buf;
328: out.next = NULL;
329:
330: rc = ngx_http_request_body_filter(r, &out);
331:
332: if (rc != NGX_OK) {
333: return rc;
334: }
335: }
336:
337: if (rb->rest == 0) {
338: break;
339: }
340:
341: if (rb->buf->last < rb->buf->end) {
342: break;
343: }
344: }
345:
346: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
347: "http client request body rest %O", rb->rest);
348:
349: if (rb->rest == 0) {
350: break;
351: }
352:
353: if (!c->read->ready) {
354: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
355: ngx_add_timer(c->read, clcf->client_body_timeout);
356:
357: if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
358: return NGX_HTTP_INTERNAL_SERVER_ERROR;
359: }
360:
361: return NGX_AGAIN;
362: }
363: }
364:
365: if (c->read->timer_set) {
366: ngx_del_timer(c->read);
367: }
368:
369: if (rb->temp_file || r->request_body_in_file_only) {
370:
371: /* save the last part */
372:
373: if (ngx_http_write_request_body(r) != NGX_OK) {
374: return NGX_HTTP_INTERNAL_SERVER_ERROR;
375: }
376:
377: cl = ngx_chain_get_free_buf(r->pool, &rb->free);
378: if (cl == NULL) {
379: return NGX_HTTP_INTERNAL_SERVER_ERROR;
380: }
381:
382: b = cl->buf;
383:
384: ngx_memzero(b, sizeof(ngx_buf_t));
385:
386: b->in_file = 1;
387: b->file_last = rb->temp_file->file.offset;
388: b->file = &rb->temp_file->file;
389:
390: rb->bufs = cl;
391: }
392:
393: r->read_event_handler = ngx_http_block_reading;
394:
395: rb->post_handler(r);
396:
397: return NGX_OK;
398: }
399:
400:
401: static ngx_int_t
402: ngx_http_write_request_body(ngx_http_request_t *r)
403: {
404: ssize_t n;
405: ngx_chain_t *cl;
406: ngx_temp_file_t *tf;
407: ngx_http_request_body_t *rb;
408: ngx_http_core_loc_conf_t *clcf;
409:
410: rb = r->request_body;
411:
412: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
413: "http write client request body, bufs %p", rb->bufs);
414:
415: if (rb->temp_file == NULL) {
416: tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
417: if (tf == NULL) {
418: return NGX_ERROR;
419: }
420:
421: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
422:
423: tf->file.fd = NGX_INVALID_FILE;
424: tf->file.log = r->connection->log;
425: tf->path = clcf->client_body_temp_path;
426: tf->pool = r->pool;
427: tf->warn = "a client request body is buffered to a temporary file";
428: tf->log_level = r->request_body_file_log_level;
429: tf->persistent = r->request_body_in_persistent_file;
430: tf->clean = r->request_body_in_clean_file;
431:
432: if (r->request_body_file_group_access) {
433: tf->access = 0660;
434: }
435:
436: rb->temp_file = tf;
437:
438: if (rb->bufs == NULL) {
439: /* empty body with r->request_body_in_file_only */
440:
441: if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
442: tf->persistent, tf->clean, tf->access)
443: != NGX_OK)
444: {
445: return NGX_ERROR;
446: }
447:
448: return NGX_OK;
449: }
450: }
451:
452: if (rb->bufs == NULL) {
453: return NGX_OK;
454: }
455:
456: n = ngx_write_chain_to_temp_file(rb->temp_file, rb->bufs);
457:
458: /* TODO: n == 0 or not complete and level event */
459:
460: if (n == NGX_ERROR) {
461: return NGX_ERROR;
462: }
463:
464: rb->temp_file->offset += n;
465:
466: /* mark all buffers as written */
467:
468: for (cl = rb->bufs; cl; cl = cl->next) {
469: cl->buf->pos = cl->buf->last;
470: }
471:
472: rb->bufs = NULL;
473:
474: return NGX_OK;
475: }
476:
477:
478: ngx_int_t
479: ngx_http_discard_request_body(ngx_http_request_t *r)
480: {
481: ssize_t size;
482: ngx_int_t rc;
483: ngx_event_t *rev;
484:
485: #if (NGX_HTTP_SPDY)
486: if (r->spdy_stream && r == r->main) {
487: r->spdy_stream->skip_data = NGX_SPDY_DATA_DISCARD;
488: return NGX_OK;
489: }
490: #endif
491:
492: if (r != r->main || r->discard_body || r->request_body) {
493: return NGX_OK;
494: }
495:
496: if (ngx_http_test_expect(r) != NGX_OK) {
497: return NGX_HTTP_INTERNAL_SERVER_ERROR;
498: }
499:
500: rev = r->connection->read;
501:
502: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0, "http set discard body");
503:
504: if (rev->timer_set) {
505: ngx_del_timer(rev);
506: }
507:
508: if (r->headers_in.content_length_n <= 0 && !r->headers_in.chunked) {
509: return NGX_OK;
510: }
511:
512: size = r->header_in->last - r->header_in->pos;
513:
514: if (size || r->headers_in.chunked) {
515: rc = ngx_http_discard_request_body_filter(r, r->header_in);
516:
517: if (rc != NGX_OK) {
518: return rc;
519: }
520:
521: if (r->headers_in.content_length_n == 0) {
522: return NGX_OK;
523: }
524: }
525:
526: rc = ngx_http_read_discarded_request_body(r);
527:
528: if (rc == NGX_OK) {
529: r->lingering_close = 0;
530: return NGX_OK;
531: }
532:
533: if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
534: return rc;
535: }
536:
537: /* rc == NGX_AGAIN */
538:
539: r->read_event_handler = ngx_http_discarded_request_body_handler;
540:
541: if (ngx_handle_read_event(rev, 0) != NGX_OK) {
542: return NGX_HTTP_INTERNAL_SERVER_ERROR;
543: }
544:
545: r->count++;
546: r->discard_body = 1;
547:
548: return NGX_OK;
549: }
550:
551:
552: void
553: ngx_http_discarded_request_body_handler(ngx_http_request_t *r)
554: {
555: ngx_int_t rc;
556: ngx_msec_t timer;
557: ngx_event_t *rev;
558: ngx_connection_t *c;
559: ngx_http_core_loc_conf_t *clcf;
560:
561: c = r->connection;
562: rev = c->read;
563:
564: if (rev->timedout) {
565: c->timedout = 1;
566: c->error = 1;
567: ngx_http_finalize_request(r, NGX_ERROR);
568: return;
569: }
570:
571: if (r->lingering_time) {
572: timer = (ngx_msec_t) (r->lingering_time - ngx_time());
573:
574: if (timer <= 0) {
575: r->discard_body = 0;
576: r->lingering_close = 0;
577: ngx_http_finalize_request(r, NGX_ERROR);
578: return;
579: }
580:
581: } else {
582: timer = 0;
583: }
584:
585: rc = ngx_http_read_discarded_request_body(r);
586:
587: if (rc == NGX_OK) {
588: r->discard_body = 0;
589: r->lingering_close = 0;
590: ngx_http_finalize_request(r, NGX_DONE);
591: return;
592: }
593:
594: if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
595: c->error = 1;
596: ngx_http_finalize_request(r, NGX_ERROR);
597: return;
598: }
599:
600: /* rc == NGX_AGAIN */
601:
602: if (ngx_handle_read_event(rev, 0) != NGX_OK) {
603: c->error = 1;
604: ngx_http_finalize_request(r, NGX_ERROR);
605: return;
606: }
607:
608: if (timer) {
609:
610: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
611:
612: timer *= 1000;
613:
614: if (timer > clcf->lingering_timeout) {
615: timer = clcf->lingering_timeout;
616: }
617:
618: ngx_add_timer(rev, timer);
619: }
620: }
621:
622:
623: static ngx_int_t
624: ngx_http_read_discarded_request_body(ngx_http_request_t *r)
625: {
626: size_t size;
627: ssize_t n;
628: ngx_int_t rc;
629: ngx_buf_t b;
630: u_char buffer[NGX_HTTP_DISCARD_BUFFER_SIZE];
631:
632: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
633: "http read discarded body");
634:
635: ngx_memzero(&b, sizeof(ngx_buf_t));
636:
637: b.temporary = 1;
638:
639: for ( ;; ) {
640: if (r->headers_in.content_length_n == 0) {
641: r->read_event_handler = ngx_http_block_reading;
642: return NGX_OK;
643: }
644:
645: if (!r->connection->read->ready) {
646: return NGX_AGAIN;
647: }
648:
649: size = (size_t) ngx_min(r->headers_in.content_length_n,
650: NGX_HTTP_DISCARD_BUFFER_SIZE);
651:
652: n = r->connection->recv(r->connection, buffer, size);
653:
654: if (n == NGX_ERROR) {
655: r->connection->error = 1;
656: return NGX_OK;
657: }
658:
659: if (n == NGX_AGAIN) {
660: return NGX_AGAIN;
661: }
662:
663: if (n == 0) {
664: return NGX_OK;
665: }
666:
667: b.pos = buffer;
668: b.last = buffer + n;
669:
670: rc = ngx_http_discard_request_body_filter(r, &b);
671:
672: if (rc != NGX_OK) {
673: return rc;
674: }
675: }
676: }
677:
678:
679: static ngx_int_t
680: ngx_http_discard_request_body_filter(ngx_http_request_t *r, ngx_buf_t *b)
681: {
682: size_t size;
683: ngx_int_t rc;
684: ngx_http_request_body_t *rb;
685:
686: if (r->headers_in.chunked) {
687:
688: rb = r->request_body;
689:
690: if (rb == NULL) {
691:
692: rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
693: if (rb == NULL) {
694: return NGX_HTTP_INTERNAL_SERVER_ERROR;
695: }
696:
697: rb->chunked = ngx_pcalloc(r->pool, sizeof(ngx_http_chunked_t));
698: if (rb->chunked == NULL) {
699: return NGX_HTTP_INTERNAL_SERVER_ERROR;
700: }
701:
702: r->request_body = rb;
703: }
704:
705: for ( ;; ) {
706:
707: rc = ngx_http_parse_chunked(r, b, rb->chunked);
708:
709: if (rc == NGX_OK) {
710:
711: /* a chunk has been parsed successfully */
712:
713: size = b->last - b->pos;
714:
715: if ((off_t) size > rb->chunked->size) {
716: b->pos += rb->chunked->size;
717: rb->chunked->size = 0;
718:
719: } else {
720: rb->chunked->size -= size;
721: b->pos = b->last;
722: }
723:
724: continue;
725: }
726:
727: if (rc == NGX_DONE) {
728:
729: /* a whole response has been parsed successfully */
730:
731: r->headers_in.content_length_n = 0;
732: break;
733: }
734:
735: if (rc == NGX_AGAIN) {
736:
737: /* set amount of data we want to see next time */
738:
739: r->headers_in.content_length_n = rb->chunked->length;
740: break;
741: }
742:
743: /* invalid */
744:
745: ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
746: "client sent invalid chunked body");
747:
748: return NGX_HTTP_BAD_REQUEST;
749: }
750:
751: } else {
752: size = b->last - b->pos;
753:
754: if ((off_t) size > r->headers_in.content_length_n) {
755: b->pos += r->headers_in.content_length_n;
756: r->headers_in.content_length_n = 0;
757:
758: } else {
759: b->pos = b->last;
760: r->headers_in.content_length_n -= size;
761: }
762: }
763:
764: return NGX_OK;
765: }
766:
767:
768: static ngx_int_t
769: ngx_http_test_expect(ngx_http_request_t *r)
770: {
771: ngx_int_t n;
772: ngx_str_t *expect;
773:
774: if (r->expect_tested
775: || r->headers_in.expect == NULL
776: || r->http_version < NGX_HTTP_VERSION_11)
777: {
778: return NGX_OK;
779: }
780:
781: r->expect_tested = 1;
782:
783: expect = &r->headers_in.expect->value;
784:
785: if (expect->len != sizeof("100-continue") - 1
786: || ngx_strncasecmp(expect->data, (u_char *) "100-continue",
787: sizeof("100-continue") - 1)
788: != 0)
789: {
790: return NGX_OK;
791: }
792:
793: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
794: "send 100 Continue");
795:
796: n = r->connection->send(r->connection,
797: (u_char *) "HTTP/1.1 100 Continue" CRLF CRLF,
798: sizeof("HTTP/1.1 100 Continue" CRLF CRLF) - 1);
799:
800: if (n == sizeof("HTTP/1.1 100 Continue" CRLF CRLF) - 1) {
801: return NGX_OK;
802: }
803:
804: /* we assume that such small packet should be send successfully */
805:
806: return NGX_ERROR;
807: }
808:
809:
810: static ngx_int_t
811: ngx_http_request_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
812: {
813: if (r->headers_in.chunked) {
814: return ngx_http_request_body_chunked_filter(r, in);
815:
816: } else {
817: return ngx_http_request_body_length_filter(r, in);
818: }
819: }
820:
821:
822: static ngx_int_t
823: ngx_http_request_body_length_filter(ngx_http_request_t *r, ngx_chain_t *in)
824: {
825: size_t size;
826: ngx_int_t rc;
827: ngx_buf_t *b;
828: ngx_chain_t *cl, *tl, *out, **ll;
829: ngx_http_request_body_t *rb;
830:
831: rb = r->request_body;
832:
833: if (rb->rest == -1) {
834: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
835: "http request body content length filter");
836:
837: rb->rest = r->headers_in.content_length_n;
838: }
839:
840: out = NULL;
841: ll = &out;
842:
843: for (cl = in; cl; cl = cl->next) {
844:
845: tl = ngx_chain_get_free_buf(r->pool, &rb->free);
846: if (tl == NULL) {
847: return NGX_HTTP_INTERNAL_SERVER_ERROR;
848: }
849:
850: b = tl->buf;
851:
852: ngx_memzero(b, sizeof(ngx_buf_t));
853:
854: b->temporary = 1;
855: b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
856: b->start = cl->buf->pos;
857: b->pos = cl->buf->pos;
858: b->last = cl->buf->last;
859: b->end = cl->buf->end;
860:
861: size = cl->buf->last - cl->buf->pos;
862:
863: if ((off_t) size < rb->rest) {
864: cl->buf->pos = cl->buf->last;
865: rb->rest -= size;
866:
867: } else {
868: cl->buf->pos += rb->rest;
869: rb->rest = 0;
870: b->last = cl->buf->pos;
871: b->last_buf = 1;
872: }
873:
874: *ll = tl;
875: ll = &tl->next;
876: }
877:
878: rc = ngx_http_request_body_save_filter(r, out);
879:
880: ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &out,
881: (ngx_buf_tag_t) &ngx_http_read_client_request_body);
882:
883: return rc;
884: }
885:
886:
887: static ngx_int_t
888: ngx_http_request_body_chunked_filter(ngx_http_request_t *r, ngx_chain_t *in)
889: {
890: size_t size;
891: ngx_int_t rc;
892: ngx_buf_t *b;
893: ngx_chain_t *cl, *out, *tl, **ll;
894: ngx_http_request_body_t *rb;
895: ngx_http_core_loc_conf_t *clcf;
896:
897: rb = r->request_body;
898:
899: if (rb->rest == -1) {
900:
901: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
902: "http request body chunked filter");
903:
904: rb->chunked = ngx_pcalloc(r->pool, sizeof(ngx_http_chunked_t));
905: if (rb->chunked == NULL) {
906: return NGX_HTTP_INTERNAL_SERVER_ERROR;
907: }
908:
909: r->headers_in.content_length_n = 0;
910: rb->rest = 3;
911: }
912:
913: out = NULL;
914: ll = &out;
915:
916: for (cl = in; cl; cl = cl->next) {
917:
918: for ( ;; ) {
919:
920: ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
921: "http body chunked buf "
922: "t:%d f:%d %p, pos %p, size: %z file: %O, size: %z",
923: cl->buf->temporary, cl->buf->in_file,
924: cl->buf->start, cl->buf->pos,
925: cl->buf->last - cl->buf->pos,
926: cl->buf->file_pos,
927: cl->buf->file_last - cl->buf->file_pos);
928:
929: rc = ngx_http_parse_chunked(r, cl->buf, rb->chunked);
930:
931: if (rc == NGX_OK) {
932:
933: /* a chunk has been parsed successfully */
934:
935: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
936:
937: if (clcf->client_max_body_size
938: && clcf->client_max_body_size
939: < r->headers_in.content_length_n + rb->chunked->size)
940: {
941: ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
942: "client intended to send too large chunked "
943: "body: %O bytes",
944: r->headers_in.content_length_n
945: + rb->chunked->size);
946:
947: r->lingering_close = 1;
948:
949: return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
950: }
951:
952: tl = ngx_chain_get_free_buf(r->pool, &rb->free);
953: if (tl == NULL) {
954: return NGX_HTTP_INTERNAL_SERVER_ERROR;
955: }
956:
957: b = tl->buf;
958:
959: ngx_memzero(b, sizeof(ngx_buf_t));
960:
961: b->temporary = 1;
962: b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
963: b->start = cl->buf->pos;
964: b->pos = cl->buf->pos;
965: b->last = cl->buf->last;
966: b->end = cl->buf->end;
967:
968: *ll = tl;
969: ll = &tl->next;
970:
971: size = cl->buf->last - cl->buf->pos;
972:
973: if ((off_t) size > rb->chunked->size) {
974: cl->buf->pos += rb->chunked->size;
975: r->headers_in.content_length_n += rb->chunked->size;
976: rb->chunked->size = 0;
977:
978: } else {
979: rb->chunked->size -= size;
980: r->headers_in.content_length_n += size;
981: cl->buf->pos = cl->buf->last;
982: }
983:
984: b->last = cl->buf->pos;
985:
986: continue;
987: }
988:
989: if (rc == NGX_DONE) {
990:
991: /* a whole response has been parsed successfully */
992:
993: rb->rest = 0;
994:
995: tl = ngx_chain_get_free_buf(r->pool, &rb->free);
996: if (tl == NULL) {
997: return NGX_HTTP_INTERNAL_SERVER_ERROR;
998: }
999:
1000: b = tl->buf;
1001:
1002: ngx_memzero(b, sizeof(ngx_buf_t));
1003:
1004: b->last_buf = 1;
1005:
1006: *ll = tl;
1007: ll = &tl->next;
1008:
1009: break;
1010: }
1011:
1012: if (rc == NGX_AGAIN) {
1013:
1014: /* set rb->rest, amount of data we want to see next time */
1015:
1016: rb->rest = rb->chunked->length;
1017:
1018: break;
1019: }
1020:
1021: /* invalid */
1022:
1023: ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
1024: "client sent invalid chunked body");
1025:
1026: return NGX_HTTP_BAD_REQUEST;
1027: }
1028: }
1029:
1030: rc = ngx_http_request_body_save_filter(r, out);
1031:
1032: ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &out,
1033: (ngx_buf_tag_t) &ngx_http_read_client_request_body);
1034:
1035: return rc;
1036: }
1037:
1038:
1039: static ngx_int_t
1040: ngx_http_request_body_save_filter(ngx_http_request_t *r, ngx_chain_t *in)
1041: {
1042: #if (NGX_DEBUG)
1043: ngx_chain_t *cl;
1044: #endif
1045: ngx_http_request_body_t *rb;
1046:
1047: rb = r->request_body;
1048:
1049: #if (NGX_DEBUG)
1050:
1051: for (cl = rb->bufs; cl; cl = cl->next) {
1052: ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
1053: "http body old buf t:%d f:%d %p, pos %p, size: %z "
1054: "file: %O, size: %z",
1055: cl->buf->temporary, cl->buf->in_file,
1056: cl->buf->start, cl->buf->pos,
1057: cl->buf->last - cl->buf->pos,
1058: cl->buf->file_pos,
1059: cl->buf->file_last - cl->buf->file_pos);
1060: }
1061:
1062: for (cl = in; cl; cl = cl->next) {
1063: ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
1064: "http body new buf t:%d f:%d %p, pos %p, size: %z "
1065: "file: %O, size: %z",
1066: cl->buf->temporary, cl->buf->in_file,
1067: cl->buf->start, cl->buf->pos,
1068: cl->buf->last - cl->buf->pos,
1069: cl->buf->file_pos,
1070: cl->buf->file_last - cl->buf->file_pos);
1071: }
1072:
1073: #endif
1074:
1075: /* TODO: coalesce neighbouring buffers */
1076:
1077: if (ngx_chain_add_copy(r->pool, &rb->bufs, in) != NGX_OK) {
1078: return NGX_HTTP_INTERNAL_SERVER_ERROR;
1079: }
1080:
1081: return NGX_OK;
1082: }