One Level Up Top Level

src/http/ngx_http_request_body.c - nginx-1.7.10

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  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);

  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);


  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;

  43.     r->main->count++;

  45. #if (NGX_HTTP_SPDY)
  46.     if (r->spdy_stream && r == r->main) {
  47.         rc = ngx_http_spdy_read_request_body(r, post_handler);
  48.         goto done;
  49.     }
  50. #endif

  52.     if (r != r->main || r->request_body || r->discard_body) {
  53.         post_handler(r);
  54.         return NGX_OK;
  55.     }

  57.     if (ngx_http_test_expect(r) != NGX_OK) {
  58.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  59.         goto done;
  60.     }

  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.     }

  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.      */

  78.     rb->rest = -1;
  79.     rb->post_handler = post_handler;

  81.     r->request_body = rb;

  83.     if (r->headers_in.content_length_n < 0 && !r->headers_in.chunked) {
  84.         post_handler(r);
  85.         return NGX_OK;
  86.     }

  88.     preread = r->header_in->last - r->header_in->pos;

  90.     if (preread) {

  92.         /* there is the pre-read part of the request body */

  94.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  95.                        "http client request body preread %uz", preread);

  97.         out.buf = r->header_in;
  98.         out.next = NULL;

  100.         rc = ngx_http_request_body_filter(r, &out);

  102.         if (rc != NGX_OK) {
  103.             goto done;
  104.         }

  106.         r->request_length += preread - (r->header_in->last - r->header_in->pos);

  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 */

  114.             b = ngx_calloc_buf(r->pool);
  115.             if (b == NULL) {
  116.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  117.                 goto done;
  118.             }

  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;

  126.             rb->buf = b;

  128.             r->read_event_handler = ngx_http_read_client_request_body_handler;
  129.             r->write_event_handler = ngx_http_request_empty_handler;

  131.             rc = ngx_http_do_read_client_request_body(r);
  132.             goto done;
  133.         }

  135.     } else {
  136.         /* set rb->rest */

  138.         if (ngx_http_request_body_filter(r, NULL) != NGX_OK) {
  139.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  140.             goto done;
  141.         }
  142.     }

  144.     if (rb->rest == 0) {
  145.         /* the whole request body was pre-read */

  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.             }

  153.             if (rb->temp_file->file.offset != 0) {

  155.                 cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  156.                 if (cl == NULL) {
  157.                     rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  158.                     goto done;
  159.                 }

  161.                 b = cl->buf;

  163.                 ngx_memzero(b, sizeof(ngx_buf_t));

  165.                 b->in_file = 1;
  166.                 b->file_last = rb->temp_file->file.offset;
  167.                 b->file = &rb->temp_file->file;

  169.                 rb->bufs = cl;

  171.             } else {
  172.                 rb->bufs = NULL;
  173.             }
  174.         }

  176.         post_handler(r);

  178.         return NGX_OK;
  179.     }

  181.     if (rb->rest < 0) {
  182.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  183.                       "negative request body rest");
  184.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  185.         goto done;
  186.     }

  188.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  190.     size = clcf->client_body_buffer_size;
  191.     size += size >> 2;

  193.     /* TODO: honor r->request_body_in_single_buf */

  195.     if (!r->headers_in.chunked && rb->rest < size) {
  196.         size = (ssize_t) rb->rest;

  198.         if (r->request_body_in_single_buf) {
  199.             size += preread;
  200.         }

  202.     } else {
  203.         size = clcf->client_body_buffer_size;
  204.     }

  206.     rb->buf = ngx_create_temp_buf(r->pool, size);
  207.     if (rb->buf == NULL) {
  208.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  209.         goto done;
  210.     }

  212.     r->read_event_handler = ngx_http_read_client_request_body_handler;
  213.     r->write_event_handler = ngx_http_request_empty_handler;

  215.     rc = ngx_http_do_read_client_request_body(r);

  217. done:

  219.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  220.         r->main->count--;
  221.     }

  223.     return rc;
  224. }


  227. static void
  228. ‌ngx_http_read_client_request_body_handler(ngx_http_request_t *r)
  229. {
  230.     ngx_int_t  rc;

  232.     if (r->connection->read->timedout) {
  233.         r->connection->timedout = 1;
  234.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  235.         return;
  236.     }

  238.     rc = ngx_http_do_read_client_request_body(r);

  240.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  241.         ngx_http_finalize_request(r, rc);
  242.     }
  243. }


  246. static ngx_int_t
  247. ‌ngx_http_do_read_client_request_body(ngx_http_request_t *r)
  248. {
  249.     off_t                      rest;
  250.     size_t                     size;
  251.     ssize_t                    n;
  252.     ngx_int_t                  rc;
  253.     ngx_buf_t                 *b;
  254.     ngx_chain_t               *cl, out;
  255.     ngx_connection_t          *c;
  256.     ngx_http_request_body_t   *rb;
  257.     ngx_http_core_loc_conf_t  *clcf;

  259.     c = r->connection;
  260.     rb = r->request_body;

  262.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  263.                    "http read client request body");

  265.     for ( ;; ) {
  266.         for ( ;; ) {
  267.             if (rb->buf->last == rb->buf->end) {

  269.                 /* pass buffer to request body filter chain */

  271.                 out.buf = rb->buf;
  272.                 out.next = NULL;

  274.                 rc = ngx_http_request_body_filter(r, &out);

  276.                 if (rc != NGX_OK) {
  277.                     return rc;
  278.                 }

  280.                 /* write to file */

  282.                 if (ngx_http_write_request_body(r) != NGX_OK) {
  283.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  284.                 }

  286.                 /* update chains */

  288.                 rc = ngx_http_request_body_filter(r, NULL);

  290.                 if (rc != NGX_OK) {
  291.                     return rc;
  292.                 }

  294.                 if (rb->busy != NULL) {
  295.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  296.                 }

  298.                 rb->buf->pos = rb->buf->start;
  299.                 rb->buf->last = rb->buf->start;
  300.             }

  302.             size = rb->buf->end - rb->buf->last;
  303.             rest = rb->rest - (rb->buf->last - rb->buf->pos);

  305.             if ((off_t) size > rest) {
  306.                 size = (size_t) rest;
  307.             }

  309.             n = c->recv(c, rb->buf->last, size);

  311.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  312.                            "http client request body recv %z", n);

  314.             if (n == NGX_AGAIN) {
  315.                 break;
  316.             }

  318.             if (n == 0) {
  319.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  320.                               "client prematurely closed connection");
  321.             }

  323.             if (n == 0 || n == NGX_ERROR) {
  324.                 c->error = 1;
  325.                 return NGX_HTTP_BAD_REQUEST;
  326.             }

  328.             rb->buf->last += n;
  329.             r->request_length += n;

  331.             if (n == rest) {
  332.                 /* pass buffer to request body filter chain */

  334.                 out.buf = rb->buf;
  335.                 out.next = NULL;

  337.                 rc = ngx_http_request_body_filter(r, &out);

  339.                 if (rc != NGX_OK) {
  340.                     return rc;
  341.                 }
  342.             }

  344.             if (rb->rest == 0) {
  345.                 break;
  346.             }

  348.             if (rb->buf->last < rb->buf->end) {
  349.                 break;
  350.             }
  351.         }

  353.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  354.                        "http client request body rest %O", rb->rest);

  356.         if (rb->rest == 0) {
  357.             break;
  358.         }

  360.         if (!c->read->ready) {
  361.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  362.             ngx_add_timer(c->read, clcf->client_body_timeout);

  364.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  365.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  366.             }

  368.             return NGX_AGAIN;
  369.         }
  370.     }

  372.     if (c->read->timer_set) {
  373.         ngx_del_timer(c->read);
  374.     }

  376.     if (rb->temp_file || r->request_body_in_file_only) {

  378.         /* save the last part */

  380.         if (ngx_http_write_request_body(r) != NGX_OK) {
  381.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  382.         }

  384.         if (rb->temp_file->file.offset != 0) {

  386.             cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  387.             if (cl == NULL) {
  388.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  389.             }

  391.             b = cl->buf;

  393.             ngx_memzero(b, sizeof(ngx_buf_t));

  395.             b->in_file = 1;
  396.             b->file_last = rb->temp_file->file.offset;
  397.             b->file = &rb->temp_file->file;

  399.             rb->bufs = cl;

  401.         } else {
  402.             rb->bufs = NULL;
  403.         }
  404.     }

  406.     r->read_event_handler = ngx_http_block_reading;

  408.     rb->post_handler(r);

  410.     return NGX_OK;
  411. }


  414. static ngx_int_t
  415. ‌ngx_http_write_request_body(ngx_http_request_t *r)
  416. {
  417.     ssize_t                    n;
  418.     ngx_chain_t               *cl;
  419.     ngx_temp_file_t           *tf;
  420.     ngx_http_request_body_t   *rb;
  421.     ngx_http_core_loc_conf_t  *clcf;

  423.     rb = r->request_body;

  425.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  426.                    "http write client request body, bufs %p", rb->bufs);

  428.     if (rb->temp_file == NULL) {
  429.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  430.         if (tf == NULL) {
  431.             return NGX_ERROR;
  432.         }

  434.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  436.         tf->file.fd = NGX_INVALID_FILE;
  437.         tf->file.log = r->connection->log;
  438.         tf->path = clcf->client_body_temp_path;
  439.         tf->pool = r->pool;
  440.         tf->warn = "a client request body is buffered to a temporary file";
  441.         tf->log_level = r->request_body_file_log_level;
  442.         tf->persistent = r->request_body_in_persistent_file;
  443.         tf->clean = r->request_body_in_clean_file;

  445.         if (r->request_body_file_group_access) {
  446.             tf->access = 0660;
  447.         }

  449.         rb->temp_file = tf;

  451.         if (rb->bufs == NULL) {
  452.             /* empty body with r->request_body_in_file_only */

  454.             if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  455.                                      tf->persistent, tf->clean, tf->access)
  456.                 != NGX_OK)
  457.             {
  458.                 return NGX_ERROR;
  459.             }

  461.             return NGX_OK;
  462.         }
  463.     }

  465.     if (rb->bufs == NULL) {
  466.         return NGX_OK;
  467.     }

  469.     n = ngx_write_chain_to_temp_file(rb->temp_file, rb->bufs);

  471.     /* TODO: n == 0 or not complete and level event */

  473.     if (n == NGX_ERROR) {
  474.         return NGX_ERROR;
  475.     }

  477.     rb->temp_file->offset += n;

  479.     /* mark all buffers as written */

  481.     for (cl = rb->bufs; cl; cl = cl->next) {
  482.         cl->buf->pos = cl->buf->last;
  483.     }

  485.     rb->bufs = NULL;

  487.     return NGX_OK;
  488. }


  491. ngx_int_t
  492. ‌ngx_http_discard_request_body(ngx_http_request_t *r)
  493. {
  494.     ssize_t       size;
  495.     ngx_int_t     rc;
  496.     ngx_event_t  *rev;

  498. #if (NGX_HTTP_SPDY)
  499.     if (r->spdy_stream && r == r->main) {
  500.         r->spdy_stream->skip_data = NGX_SPDY_DATA_DISCARD;
  501.         return NGX_OK;
  502.     }
  503. #endif

  505.     if (r != r->main || r->discard_body || r->request_body) {
  506.         return NGX_OK;
  507.     }

  509.     if (ngx_http_test_expect(r) != NGX_OK) {
  510.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  511.     }

  513.     rev = r->connection->read;

  515.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0, "http set discard body");

  517.     if (rev->timer_set) {
  518.         ngx_del_timer(rev);
  519.     }

  521.     if (r->headers_in.content_length_n <= 0 && !r->headers_in.chunked) {
  522.         return NGX_OK;
  523.     }

  525.     size = r->header_in->last - r->header_in->pos;

  527.     if (size || r->headers_in.chunked) {
  528.         rc = ngx_http_discard_request_body_filter(r, r->header_in);

  530.         if (rc != NGX_OK) {
  531.             return rc;
  532.         }

  534.         if (r->headers_in.content_length_n == 0) {
  535.             return NGX_OK;
  536.         }
  537.     }

  539.     rc = ngx_http_read_discarded_request_body(r);

  541.     if (rc == NGX_OK) {
  542.         r->lingering_close = 0;
  543.         return NGX_OK;
  544.     }

  546.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  547.         return rc;
  548.     }

  550.     /* rc == NGX_AGAIN */

  552.     r->read_event_handler = ngx_http_discarded_request_body_handler;

  554.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  555.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  556.     }

  558.     r->count++;
  559.     r->discard_body = 1;

  561.     return NGX_OK;
  562. }


  565. void
  566. ‌ngx_http_discarded_request_body_handler(ngx_http_request_t *r)
  567. {
  568.     ngx_int_t                  rc;
  569.     ngx_msec_t                 timer;
  570.     ngx_event_t               *rev;
  571.     ngx_connection_t          *c;
  572.     ngx_http_core_loc_conf_t  *clcf;

  574.     c = r->connection;
  575.     rev = c->read;

  577.     if (rev->timedout) {
  578.         c->timedout = 1;
  579.         c->error = 1;
  580.         ngx_http_finalize_request(r, NGX_ERROR);
  581.         return;
  582.     }

  584.     if (r->lingering_time) {
  585.         timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();

  587.         if ((ngx_msec_int_t) timer <= 0) {
  588.             r->discard_body = 0;
  589.             r->lingering_close = 0;
  590.             ngx_http_finalize_request(r, NGX_ERROR);
  591.             return;
  592.         }

  594.     } else {
  595.         timer = 0;
  596.     }

  598.     rc = ngx_http_read_discarded_request_body(r);

  600.     if (rc == NGX_OK) {
  601.         r->discard_body = 0;
  602.         r->lingering_close = 0;
  603.         ngx_http_finalize_request(r, NGX_DONE);
  604.         return;
  605.     }

  607.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  608.         c->error = 1;
  609.         ngx_http_finalize_request(r, NGX_ERROR);
  610.         return;
  611.     }

  613.     /* rc == NGX_AGAIN */

  615.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  616.         c->error = 1;
  617.         ngx_http_finalize_request(r, NGX_ERROR);
  618.         return;
  619.     }

  621.     if (timer) {

  623.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  625.         timer *= 1000;

  627.         if (timer > clcf->lingering_timeout) {
  628.             timer = clcf->lingering_timeout;
  629.         }

  631.         ngx_add_timer(rev, timer);
  632.     }
  633. }


  636. static ngx_int_t
  637. ‌ngx_http_read_discarded_request_body(ngx_http_request_t *r)
  638. {
  639.     size_t     size;
  640.     ssize_t    n;
  641.     ngx_int_t  rc;
  642.     ngx_buf_t  b;
  643.     u_char     buffer[NGX_HTTP_DISCARD_BUFFER_SIZE];

  645.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  646.                    "http read discarded body");

  648.     ngx_memzero(&b, sizeof(ngx_buf_t));

  650.     b.temporary = 1;

  652.     for ( ;; ) {
  653.         if (r->headers_in.content_length_n == 0) {
  654.             r->read_event_handler = ngx_http_block_reading;
  655.             return NGX_OK;
  656.         }

  658.         if (!r->connection->read->ready) {
  659.             return NGX_AGAIN;
  660.         }

  662.         size = (size_t) ngx_min(r->headers_in.content_length_n,
  663.                                 NGX_HTTP_DISCARD_BUFFER_SIZE);

  665.         n = r->connection->recv(r->connection, buffer, size);

  667.         if (n == NGX_ERROR) {
  668.             r->connection->error = 1;
  669.             return NGX_OK;
  670.         }

  672.         if (n == NGX_AGAIN) {
  673.             return NGX_AGAIN;
  674.         }

  676.         if (n == 0) {
  677.             return NGX_OK;
  678.         }

  680.         b.pos = buffer;
  681.         b.last = buffer + n;

  683.         rc = ngx_http_discard_request_body_filter(r, &b);

  685.         if (rc != NGX_OK) {
  686.             return rc;
  687.         }
  688.     }
  689. }


  692. static ngx_int_t
  693. ‌ngx_http_discard_request_body_filter(ngx_http_request_t *r, ngx_buf_t *b)
  694. {
  695.     size_t                    size;
  696.     ngx_int_t                 rc;
  697.     ngx_http_request_body_t  *rb;

  699.     if (r->headers_in.chunked) {

  701.         rb = r->request_body;

  703.         if (rb == NULL) {

  705.             rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
  706.             if (rb == NULL) {
  707.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  708.             }

  710.             rb->chunked = ngx_pcalloc(r->pool, sizeof(ngx_http_chunked_t));
  711.             if (rb->chunked == NULL) {
  712.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  713.             }

  715.             r->request_body = rb;
  716.         }

  718.         for ( ;; ) {

  720.             rc = ngx_http_parse_chunked(r, b, rb->chunked);

  722.             if (rc == NGX_OK) {

  724.                 /* a chunk has been parsed successfully */

  726.                 size = b->last - b->pos;

  728.                 if ((off_t) size > rb->chunked->size) {
  729.                     b->pos += (size_t) rb->chunked->size;
  730.                     rb->chunked->size = 0;

  732.                 } else {
  733.                     rb->chunked->size -= size;
  734.                     b->pos = b->last;
  735.                 }

  737.                 continue;
  738.             }

  740.             if (rc == NGX_DONE) {

  742.                 /* a whole response has been parsed successfully */

  744.                 r->headers_in.content_length_n = 0;
  745.                 break;
  746.             }

  748.             if (rc == NGX_AGAIN) {

  750.                 /* set amount of data we want to see next time */

  752.                 r->headers_in.content_length_n = rb->chunked->length;
  753.                 break;
  754.             }

  756.             /* invalid */

  758.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  759.                           "client sent invalid chunked body");

  761.             return NGX_HTTP_BAD_REQUEST;
  762.         }

  764.     } else {
  765.         size = b->last - b->pos;

  767.         if ((off_t) size > r->headers_in.content_length_n) {
  768.             b->pos += (size_t) r->headers_in.content_length_n;
  769.             r->headers_in.content_length_n = 0;

  771.         } else {
  772.             b->pos = b->last;
  773.             r->headers_in.content_length_n -= size;
  774.         }
  775.     }

  777.     return NGX_OK;
  778. }


  781. static ngx_int_t
  782. ‌ngx_http_test_expect(ngx_http_request_t *r)
  783. {
  784.     ngx_int_t   n;
  785.     ngx_str_t  *expect;

  787.     if (r->expect_tested
  788.         || r->headers_in.expect == NULL
  789.         || r->http_version < NGX_HTTP_VERSION_11)
  790.     {
  791.         return NGX_OK;
  792.     }

  794.     r->expect_tested = 1;

  796.     expect = &r->headers_in.expect->value;

  798.     if (expect->len != sizeof("100-continue") - 1
  799.         || ngx_strncasecmp(expect->data, (u_char *) "100-continue",
  800.                            sizeof("100-continue") - 1)
  801.            != 0)
  802.     {
  803.         return NGX_OK;
  804.     }

  806.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  807.                    "send 100 Continue");

  809.     n = r->connection->send(r->connection,
  810.                             (u_char *) "HTTP/1.1 100 Continue" CRLF CRLF,
  811.                             sizeof("HTTP/1.1 100 Continue" CRLF CRLF) - 1);

  813.     if (n == sizeof("HTTP/1.1 100 Continue" CRLF CRLF) - 1) {
  814.         return NGX_OK;
  815.     }

  817.     /* we assume that such small packet should be send successfully */

  819.     return NGX_ERROR;
  820. }


  823. static ngx_int_t
  824. ‌ngx_http_request_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  825. {
  826.     if (r->headers_in.chunked) {
  827.         return ngx_http_request_body_chunked_filter(r, in);

  829.     } else {
  830.         return ngx_http_request_body_length_filter(r, in);
  831.     }
  832. }


  835. static ngx_int_t
  836. ‌ngx_http_request_body_length_filter(ngx_http_request_t *r, ngx_chain_t *in)
  837. {
  838.     size_t                     size;
  839.     ngx_int_t                  rc;
  840.     ngx_buf_t                 *b;
  841.     ngx_chain_t               *cl, *tl, *out, **ll;
  842.     ngx_http_request_body_t   *rb;

  844.     rb = r->request_body;

  846.     if (rb->rest == -1) {
  847.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  848.                        "http request body content length filter");

  850.         rb->rest = r->headers_in.content_length_n;
  851.     }

  853.     out = NULL;
  854.     ll = &out;

  856.     for (cl = in; cl; cl = cl->next) {

  858.         if (rb->rest == 0) {
  859.             break;
  860.         }

  862.         tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  863.         if (tl == NULL) {
  864.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  865.         }

  867.         b = tl->buf;

  869.         ngx_memzero(b, sizeof(ngx_buf_t));

  871.         b->temporary = 1;
  872.         b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
  873.         b->start = cl->buf->pos;
  874.         b->pos = cl->buf->pos;
  875.         b->last = cl->buf->last;
  876.         b->end = cl->buf->end;

  878.         size = cl->buf->last - cl->buf->pos;

  880.         if ((off_t) size < rb->rest) {
  881.             cl->buf->pos = cl->buf->last;
  882.             rb->rest -= size;

  884.         } else {
  885.             cl->buf->pos += (size_t) rb->rest;
  886.             rb->rest = 0;
  887.             b->last = cl->buf->pos;
  888.             b->last_buf = 1;
  889.         }

  891.         *ll = tl;
  892.         ll = &tl->next;
  893.     }

  895.     rc = ngx_http_request_body_save_filter(r, out);

  897.     ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &out,
  898.                             (ngx_buf_tag_t) &ngx_http_read_client_request_body);

  900.     return rc;
  901. }


  904. static ngx_int_t
  905. ‌ngx_http_request_body_chunked_filter(ngx_http_request_t *r, ngx_chain_t *in)
  906. {
  907.     size_t                     size;
  908.     ngx_int_t                  rc;
  909.     ngx_buf_t                 *b;
  910.     ngx_chain_t               *cl, *out, *tl, **ll;
  911.     ngx_http_request_body_t   *rb;
  912.     ngx_http_core_loc_conf_t  *clcf;

  914.     rb = r->request_body;

  916.     if (rb->rest == -1) {

  918.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  919.                        "http request body chunked filter");

  921.         rb->chunked = ngx_pcalloc(r->pool, sizeof(ngx_http_chunked_t));
  922.         if (rb->chunked == NULL) {
  923.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  924.         }

  926.         r->headers_in.content_length_n = 0;
  927.         rb->rest = 3;
  928.     }

  930.     out = NULL;
  931.     ll = &out;

  933.     for (cl = in; cl; cl = cl->next) {

  935.         for ( ;; ) {

  937.             ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  938.                            "http body chunked buf "
  939.                            "t:%d f:%d %p, pos %p, size: %z file: %O, size: %z",
  940.                            cl->buf->temporary, cl->buf->in_file,
  941.                            cl->buf->start, cl->buf->pos,
  942.                            cl->buf->last - cl->buf->pos,
  943.                            cl->buf->file_pos,
  944.                            cl->buf->file_last - cl->buf->file_pos);

  946.             rc = ngx_http_parse_chunked(r, cl->buf, rb->chunked);

  948.             if (rc == NGX_OK) {

  950.                 /* a chunk has been parsed successfully */

  952.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  954.                 if (clcf->client_max_body_size
  955.                     && clcf->client_max_body_size
  956.                        - r->headers_in.content_length_n < rb->chunked->size)
  957.                 {
  958.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  959.                                   "client intended to send too large chunked "
  960.                                   "body: %O+%O bytes",
  961.                                   r->headers_in.content_length_n,
  962.                                   rb->chunked->size);

  964.                     r->lingering_close = 1;

  966.                     return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  967.                 }

  969.                 tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  970.                 if (tl == NULL) {
  971.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  972.                 }

  974.                 b = tl->buf;

  976.                 ngx_memzero(b, sizeof(ngx_buf_t));

  978.                 b->temporary = 1;
  979.                 b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
  980.                 b->start = cl->buf->pos;
  981.                 b->pos = cl->buf->pos;
  982.                 b->last = cl->buf->last;
  983.                 b->end = cl->buf->end;

  985.                 *ll = tl;
  986.                 ll = &tl->next;

  988.                 size = cl->buf->last - cl->buf->pos;

  990.                 if ((off_t) size > rb->chunked->size) {
  991.                     cl->buf->pos += (size_t) rb->chunked->size;
  992.                     r->headers_in.content_length_n += rb->chunked->size;
  993.                     rb->chunked->size = 0;

  995.                 } else {
  996.                     rb->chunked->size -= size;
  997.                     r->headers_in.content_length_n += size;
  998.                     cl->buf->pos = cl->buf->last;
  999.                 }

  1001.                 b->last = cl->buf->pos;

  1003.                 continue;
  1004.             }

  1006.             if (rc == NGX_DONE) {

  1008.                 /* a whole response has been parsed successfully */

  1010.                 rb->rest = 0;

  1012.                 tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1013.                 if (tl == NULL) {
  1014.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1015.                 }

  1017.                 b = tl->buf;

  1019.                 ngx_memzero(b, sizeof(ngx_buf_t));

  1021.                 b->last_buf = 1;

  1023.                 *ll = tl;
  1024.                 ll = &tl->next;

  1026.                 break;
  1027.             }

  1029.             if (rc == NGX_AGAIN) {

  1031.                 /* set rb->rest, amount of data we want to see next time */

  1033.                 rb->rest = rb->chunked->length;

  1035.                 break;
  1036.             }

  1038.             /* invalid */

  1040.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1041.                           "client sent invalid chunked body");

  1043.             return NGX_HTTP_BAD_REQUEST;
  1044.         }
  1045.     }

  1047.     rc = ngx_http_request_body_save_filter(r, out);

  1049.     ngx_chain_update_chains(r->pool, &rb->free, &rb->busy, &out,
  1050.                             (ngx_buf_tag_t) &ngx_http_read_client_request_body);

  1052.     return rc;
  1053. }


  1056. static ngx_int_t
  1057. ‌ngx_http_request_body_save_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1058. {
  1059. #if (NGX_DEBUG)
  1060.     ngx_chain_t               *cl;
  1061. #endif
  1062.     ngx_http_request_body_t   *rb;

  1064.     rb = r->request_body;

  1066. #if (NGX_DEBUG)

  1068.     for (cl = rb->bufs; cl; cl = cl->next) {
  1069.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1070.                        "http body old buf t:%d f:%d %p, pos %p, size: %z "
  1071.                        "file: %O, size: %z",
  1072.                        cl->buf->temporary, cl->buf->in_file,
  1073.                        cl->buf->start, cl->buf->pos,
  1074.                        cl->buf->last - cl->buf->pos,
  1075.                        cl->buf->file_pos,
  1076.                        cl->buf->file_last - cl->buf->file_pos);
  1077.     }

  1079.     for (cl = in; cl; cl = cl->next) {
  1080.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1081.                        "http body new buf t:%d f:%d %p, pos %p, size: %z "
  1082.                        "file: %O, size: %z",
  1083.                        cl->buf->temporary, cl->buf->in_file,
  1084.                        cl->buf->start, cl->buf->pos,
  1085.                        cl->buf->last - cl->buf->pos,
  1086.                        cl->buf->file_pos,
  1087.                        cl->buf->file_last - cl->buf->file_pos);
  1088.     }

  1090. #endif

  1092.     /* TODO: coalesce neighbouring buffers */

  1094.     if (ngx_chain_add_copy(r->pool, &rb->bufs, in) != NGX_OK) {
  1095.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1096.     }

  1098.     return NGX_OK;
  1099. }

One Level Up Top Level