One Level Up Top Level

src/http/ngx_http_request_body.c - nginx source code

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_copy_pipelined_header(ngx_http_request_t *r,
  16.     ngx_buf_t *buf);
  17. static ngx_int_t ngx_http_write_request_body(ngx_http_request_t *r);
  18. static ngx_int_t ngx_http_read_discarded_request_body(ngx_http_request_t *r);
  19. static ngx_int_t ngx_http_discard_request_body_filter(ngx_http_request_t *r,
  20.     ngx_buf_t *b);
  21. static ngx_int_t ngx_http_test_expect(ngx_http_request_t *r);

  23. static ngx_int_t ngx_http_request_body_filter(ngx_http_request_t *r,
  24.     ngx_chain_t *in);
  25. static ngx_int_t ngx_http_request_body_length_filter(ngx_http_request_t *r,
  26.     ngx_chain_t *in);
  27. static ngx_int_t ngx_http_request_body_chunked_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;
  40.     ngx_http_request_body_t   *rb;
  41.     ngx_http_core_loc_conf_t  *clcf;

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

  45.     if (r != r->main || r->request_body || r->discard_body) {
  46.         r->request_body_no_buffering = 0;
  47.         post_handler(r);
  48.         return NGX_OK;
  49.     }

  51.     if (ngx_http_test_expect(r) != NGX_OK) {
  52.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  53.         goto done;
  54.     }

  56.     rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
  57.     if (rb == NULL) {
  58.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  59.         goto done;
  60.     }

  62.     /*
  63.      * set by ngx_pcalloc():
  64.      *
  65.      *     rb->temp_file = NULL;
  66.      *     rb->bufs = NULL;
  67.      *     rb->buf = NULL;
  68.      *     rb->free = NULL;
  69.      *     rb->busy = NULL;
  70.      *     rb->chunked = NULL;
  71.      *     rb->received = 0;
  72.      *     rb->filter_need_buffering = 0;
  73.      *     rb->last_sent = 0;
  74.      *     rb->last_saved = 0;
  75.      */

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

  80.     r->request_body = rb;

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

  88. #if (NGX_HTTP_V2)
  89.     if (r->stream) {
  90.         rc = ngx_http_v2_read_request_body(r);
  91.         goto done;
  92.     }
  93. #endif

  95. #if (NGX_HTTP_V3)
  96.     if (r->http_version == NGX_HTTP_VERSION_30) {
  97.         rc = ngx_http_v3_read_request_body(r);
  98.         goto done;
  99.     }
  100. #endif

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

  104.     if (preread) {

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

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

  111.         out.buf = r->header_in;
  112.         out.next = NULL;

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

  116.         if (rc != NGX_OK) {
  117.             goto done;
  118.         }

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

  122.         if (!r->headers_in.chunked
  123.             && rb->rest > 0
  124.             && rb->rest <= (off_t) (r->header_in->end - r->header_in->last))
  125.         {
  126.             /* the whole request body may be placed in r->header_in */

  128.             b = ngx_calloc_buf(r->pool);
  129.             if (b == NULL) {
  130.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  131.                 goto done;
  132.             }

  134.             b->temporary = 1;
  135.             b->start = r->header_in->pos;
  136.             b->pos = r->header_in->pos;
  137.             b->last = r->header_in->last;
  138.             b->end = r->header_in->end;

  140.             rb->buf = b;

  142.             r->read_event_handler = ngx_http_read_client_request_body_handler;
  143.             r->write_event_handler = ngx_http_request_empty_handler;

  145.             rc = ngx_http_do_read_client_request_body(r);
  146.             goto done;
  147.         }

  149.     } else {
  150.         /* set rb->rest */

  152.         rc = ngx_http_request_body_filter(r, NULL);

  154.         if (rc != NGX_OK) {
  155.             goto done;
  156.         }
  157.     }

  159.     if (rb->rest == 0 && rb->last_saved) {
  160.         /* the whole request body was pre-read */
  161.         r->request_body_no_buffering = 0;
  162.         post_handler(r);
  163.         return NGX_OK;
  164.     }

  166.     if (rb->rest < 0) {
  167.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  168.                       "negative request body rest");
  169.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  170.         goto done;
  171.     }

  173.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  175.     size = clcf->client_body_buffer_size;
  176.     size += size >> 2;

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

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

  183.         if (r->request_body_in_single_buf) {
  184.             size += preread;
  185.         }

  187.         if (size == 0) {
  188.             size++;
  189.         }

  191.     } else {
  192.         size = clcf->client_body_buffer_size;
  193.     }

  195.     rb->buf = ngx_create_temp_buf(r->pool, size);
  196.     if (rb->buf == NULL) {
  197.         rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  198.         goto done;
  199.     }

  201.     r->read_event_handler = ngx_http_read_client_request_body_handler;
  202.     r->write_event_handler = ngx_http_request_empty_handler;

  204.     rc = ngx_http_do_read_client_request_body(r);

  206. done:

  208.     if (r->request_body_no_buffering
  209.         && (rc == NGX_OK || rc == NGX_AGAIN))
  210.     {
  211.         if (rc == NGX_OK) {
  212.             r->request_body_no_buffering = 0;

  214.         } else {
  215.             /* rc == NGX_AGAIN */
  216.             r->reading_body = 1;
  217.         }

  219.         r->read_event_handler = ngx_http_block_reading;
  220.         post_handler(r);
  221.     }

  223.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  224.         r->main->count--;
  225.     }

  227.     return rc;
  228. }


  231. ngx_int_t
  232. ‌ngx_http_read_unbuffered_request_body(ngx_http_request_t *r)
  233. {
  234.     ngx_int_t  rc;

  236. #if (NGX_HTTP_V2)
  237.     if (r->stream) {
  238.         rc = ngx_http_v2_read_unbuffered_request_body(r);

  240.         if (rc == NGX_OK) {
  241.             r->reading_body = 0;
  242.         }

  244.         return rc;
  245.     }
  246. #endif

  248. #if (NGX_HTTP_V3)
  249.     if (r->http_version == NGX_HTTP_VERSION_30) {
  250.         rc = ngx_http_v3_read_unbuffered_request_body(r);

  252.         if (rc == NGX_OK) {
  253.             r->reading_body = 0;
  254.         }

  256.         return rc;
  257.     }
  258. #endif

  260.     if (r->connection->read->timedout) {
  261.         r->connection->timedout = 1;
  262.         return NGX_HTTP_REQUEST_TIME_OUT;
  263.     }

  265.     rc = ngx_http_do_read_client_request_body(r);

  267.     if (rc == NGX_OK) {
  268.         r->reading_body = 0;
  269.     }

  271.     return rc;
  272. }


  275. static void
  276. ‌ngx_http_read_client_request_body_handler(ngx_http_request_t *r)
  277. {
  278.     ngx_int_t  rc;

  280.     if (r->connection->read->timedout) {
  281.         r->connection->timedout = 1;
  282.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  283.         return;
  284.     }

  286.     rc = ngx_http_do_read_client_request_body(r);

  288.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  289.         ngx_http_finalize_request(r, rc);
  290.     }
  291. }


  294. static ngx_int_t
  295. ‌ngx_http_do_read_client_request_body(ngx_http_request_t *r)
  296. {
  297.     off_t                      rest;
  298.     size_t                     size;
  299.     ssize_t                    n;
  300.     ngx_int_t                  rc;
  301.     ngx_uint_t                 flush;
  302.     ngx_chain_t                out;
  303.     ngx_connection_t          *c;
  304.     ngx_http_request_body_t   *rb;
  305.     ngx_http_core_loc_conf_t  *clcf;

  307.     c = r->connection;
  308.     rb = r->request_body;
  309.     flush = 1;

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

  314.     for ( ;; ) {
  315.         for ( ;; ) {
  316.             if (rb->rest == 0) {
  317.                 break;
  318.             }

  320.             if (rb->buf->last == rb->buf->end) {

  322.                 /* update chains */

  324.                 rc = ngx_http_request_body_filter(r, NULL);

  326.                 if (rc != NGX_OK) {
  327.                     return rc;
  328.                 }

  330.                 if (rb->busy != NULL) {
  331.                     if (r->request_body_no_buffering) {
  332.                         if (c->read->timer_set) {
  333.                             ngx_del_timer(c->read);
  334.                         }

  336.                         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  337.                             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  338.                         }

  340.                         return NGX_AGAIN;
  341.                     }

  343.                     if (rb->filter_need_buffering) {
  344.                         clcf = ngx_http_get_module_loc_conf(r,
  345.                                                          ngx_http_core_module);
  346.                         ngx_add_timer(c->read, clcf->client_body_timeout);

  348.                         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  349.                             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  350.                         }

  352.                         return NGX_AGAIN;
  353.                     }

  355.                     ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  356.                                   "busy buffers after request body flush");

  358.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  359.                 }

  361.                 flush = 0;
  362.                 rb->buf->pos = rb->buf->start;
  363.                 rb->buf->last = rb->buf->start;
  364.             }

  366.             size = rb->buf->end - rb->buf->last;
  367.             rest = rb->rest - (rb->buf->last - rb->buf->pos);

  369.             if ((off_t) size > rest) {
  370.                 size = (size_t) rest;
  371.             }

  373.             if (size == 0) {
  374.                 break;
  375.             }

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

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

  382.             if (n == NGX_AGAIN) {
  383.                 break;
  384.             }

  386.             if (n == 0) {
  387.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  388.                               "client prematurely closed connection");
  389.             }

  391.             if (n == 0 || n == NGX_ERROR) {
  392.                 c->error = 1;
  393.                 return NGX_HTTP_BAD_REQUEST;
  394.             }

  396.             rb->buf->last += n;
  397.             r->request_length += n;

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

  401.             flush = 0;
  402.             out.buf = rb->buf;
  403.             out.next = NULL;

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

  407.             if (rc != NGX_OK) {
  408.                 return rc;
  409.             }

  411.             if (rb->rest == 0) {
  412.                 break;
  413.             }

  415.             if (rb->buf->last < rb->buf->end) {
  416.                 break;
  417.             }
  418.         }

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

  423.         if (flush) {
  424.             rc = ngx_http_request_body_filter(r, NULL);

  426.             if (rc != NGX_OK) {
  427.                 return rc;
  428.             }
  429.         }

  431.         if (rb->rest == 0 && rb->last_saved) {
  432.             break;
  433.         }

  435.         if (!c->read->ready || rb->rest == 0) {

  437.             clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  438.             ngx_add_timer(c->read, clcf->client_body_timeout);

  440.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  441.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  442.             }

  444.             return NGX_AGAIN;
  445.         }
  446.     }

  448.     if (ngx_http_copy_pipelined_header(r, rb->buf) != NGX_OK) {
  449.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  450.     }

  452.     if (c->read->timer_set) {
  453.         ngx_del_timer(c->read);
  454.     }

  456.     if (!r->request_body_no_buffering) {
  457.         r->read_event_handler = ngx_http_block_reading;
  458.         rb->post_handler(r);
  459.     }

  461.     return NGX_OK;
  462. }


  465. static ngx_int_t
  466. ‌ngx_http_copy_pipelined_header(ngx_http_request_t *r, ngx_buf_t *buf)
  467. {
  468.     size_t                     n;
  469.     ngx_buf_t                 *b;
  470.     ngx_chain_t               *cl;
  471.     ngx_http_connection_t     *hc;
  472.     ngx_http_core_srv_conf_t  *cscf;

  474.     b = r->header_in;
  475.     n = buf->last - buf->pos;

  477.     if (buf == b || n == 0) {
  478.         return NGX_OK;
  479.     }

  481.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  482.                    "http body pipelined header: %uz", n);

  484.     /*
  485.      * if there is a pipelined request in the client body buffer,
  486.      * copy it to the r->header_in buffer if there is enough room,
  487.      * or allocate a large client header buffer
  488.      */

  490.     if (n > (size_t) (b->end - b->last)) {

  492.         hc = r->http_connection;

  494.         if (hc->free) {
  495.             cl = hc->free;
  496.             hc->free = cl->next;

  498.             b = cl->buf;

  500.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  501.                            "http large header free: %p %uz",
  502.                            b->pos, b->end - b->last);

  504.         } else {
  505.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  507.             b = ngx_create_temp_buf(r->connection->pool,
  508.                                     cscf->large_client_header_buffers.size);
  509.             if (b == NULL) {
  510.                 return NGX_ERROR;
  511.             }

  513.             cl = ngx_alloc_chain_link(r->connection->pool);
  514.             if (cl == NULL) {
  515.                 return NGX_ERROR;
  516.             }

  518.             cl->buf = b;

  520.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  521.                            "http large header alloc: %p %uz",
  522.                            b->pos, b->end - b->last);
  523.         }

  525.         cl->next = hc->busy;
  526.         hc->busy = cl;
  527.         hc->nbusy++;

  529.         r->header_in = b;

  531.         if (n > (size_t) (b->end - b->last)) {
  532.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  533.                           "too large pipelined header after reading body");
  534.             return NGX_ERROR;
  535.         }
  536.     }

  538.     ngx_memcpy(b->last, buf->pos, n);

  540.     b->last += n;
  541.     r->request_length -= n;

  543.     return NGX_OK;
  544. }


  547. static ngx_int_t
  548. ‌ngx_http_write_request_body(ngx_http_request_t *r)
  549. {
  550.     ssize_t                    n;
  551.     ngx_chain_t               *cl, *ln;
  552.     ngx_temp_file_t           *tf;
  553.     ngx_http_request_body_t   *rb;
  554.     ngx_http_core_loc_conf_t  *clcf;

  556.     rb = r->request_body;

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

  561.     if (rb->temp_file == NULL) {
  562.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  563.         if (tf == NULL) {
  564.             return NGX_ERROR;
  565.         }

  567.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  569.         tf->file.fd = NGX_INVALID_FILE;
  570.         tf->file.log = r->connection->log;
  571.         tf->path = clcf->client_body_temp_path;
  572.         tf->pool = r->pool;
  573.         tf->warn = "a client request body is buffered to a temporary file";
  574.         tf->log_level = r->request_body_file_log_level;
  575.         tf->persistent = r->request_body_in_persistent_file;
  576.         tf->clean = r->request_body_in_clean_file;

  578.         if (r->request_body_file_group_access) {
  579.             tf->access = 0660;
  580.         }

  582.         rb->temp_file = tf;

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

  587.             if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  588.                                      tf->persistent, tf->clean, tf->access)
  589.                 != NGX_OK)
  590.             {
  591.                 return NGX_ERROR;
  592.             }

  594.             return NGX_OK;
  595.         }
  596.     }

  598.     if (rb->bufs == NULL) {
  599.         return NGX_OK;
  600.     }

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

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

  606.     if (n == NGX_ERROR) {
  607.         return NGX_ERROR;
  608.     }

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

  612.     /* mark all buffers as written */

  614.     for (cl = rb->bufs; cl; /* void */) {

  616.         cl->buf->pos = cl->buf->last;

  618.         ln = cl;
  619.         cl = cl->next;
  620.         ngx_free_chain(r->pool, ln);
  621.     }

  623.     rb->bufs = NULL;

  625.     return NGX_OK;
  626. }


  629. ngx_int_t
  630. ‌ngx_http_discard_request_body(ngx_http_request_t *r)
  631. {
  632.     ssize_t       size;
  633.     ngx_int_t     rc;
  634.     ngx_event_t  *rev;

  636.     if (r != r->main || r->discard_body || r->request_body) {
  637.         return NGX_OK;
  638.     }

  640. #if (NGX_HTTP_V2)
  641.     if (r->stream) {
  642.         r->stream->skip_data = 1;
  643.         return NGX_OK;
  644.     }
  645. #endif

  647. #if (NGX_HTTP_V3)
  648.     if (r->http_version == NGX_HTTP_VERSION_30) {
  649.         return NGX_OK;
  650.     }
  651. #endif

  653.     if (ngx_http_test_expect(r) != NGX_OK) {
  654.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  655.     }

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

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

  661.     if (rev->timer_set) {
  662.         ngx_del_timer(rev);
  663.     }

  665.     if (r->headers_in.content_length_n <= 0 && !r->headers_in.chunked) {
  666.         return NGX_OK;
  667.     }

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

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

  674.         if (rc != NGX_OK) {
  675.             return rc;
  676.         }

  678.         if (r->headers_in.content_length_n == 0) {
  679.             return NGX_OK;
  680.         }
  681.     }

  683.     rc = ngx_http_read_discarded_request_body(r);

  685.     if (rc == NGX_OK) {
  686.         r->lingering_close = 0;
  687.         return NGX_OK;
  688.     }

  690.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  691.         return rc;
  692.     }

  694.     /* rc == NGX_AGAIN */

  696.     r->read_event_handler = ngx_http_discarded_request_body_handler;

  698.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  699.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  700.     }

  702.     r->count++;
  703.     r->discard_body = 1;

  705.     return NGX_OK;
  706. }


  709. void
  710. ‌ngx_http_discarded_request_body_handler(ngx_http_request_t *r)
  711. {
  712.     ngx_int_t                  rc;
  713.     ngx_msec_t                 timer;
  714.     ngx_event_t               *rev;
  715.     ngx_connection_t          *c;
  716.     ngx_http_core_loc_conf_t  *clcf;

  718.     c = r->connection;
  719.     rev = c->read;

  721.     if (rev->timedout) {
  722.         c->timedout = 1;
  723.         c->error = 1;
  724.         ngx_http_finalize_request(r, NGX_ERROR);
  725.         return;
  726.     }

  728.     if (r->lingering_time) {
  729.         timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();

  731.         if ((ngx_msec_int_t) timer <= 0) {
  732.             r->discard_body = 0;
  733.             r->lingering_close = 0;
  734.             ngx_http_finalize_request(r, NGX_ERROR);
  735.             return;
  736.         }

  738.     } else {
  739.         timer = 0;
  740.     }

  742.     rc = ngx_http_read_discarded_request_body(r);

  744.     if (rc == NGX_OK) {
  745.         r->discard_body = 0;
  746.         r->lingering_close = 0;
  747.         r->lingering_time = 0;
  748.         ngx_http_finalize_request(r, NGX_DONE);
  749.         return;
  750.     }

  752.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  753.         c->error = 1;
  754.         ngx_http_finalize_request(r, NGX_ERROR);
  755.         return;
  756.     }

  758.     /* rc == NGX_AGAIN */

  760.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  761.         c->error = 1;
  762.         ngx_http_finalize_request(r, NGX_ERROR);
  763.         return;
  764.     }

  766.     if (timer) {

  768.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  770.         timer *= 1000;

  772.         if (timer > clcf->lingering_timeout) {
  773.             timer = clcf->lingering_timeout;
  774.         }

  776.         ngx_add_timer(rev, timer);
  777.     }
  778. }


  781. static ngx_int_t
  782. ‌ngx_http_read_discarded_request_body(ngx_http_request_t *r)
  783. {
  784.     size_t     size;
  785.     ssize_t    n;
  786.     ngx_int_t  rc;
  787.     ngx_buf_t  b;
  788.     u_char     buffer[NGX_HTTP_DISCARD_BUFFER_SIZE];

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

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

  795.     b.temporary = 1;

  797.     for ( ;; ) {
  798.         if (r->headers_in.content_length_n == 0) {
  799.             break;
  800.         }

  802.         if (!r->connection->read->ready) {
  803.             return NGX_AGAIN;
  804.         }

  806.         size = (size_t) ngx_min(r->headers_in.content_length_n,
  807.                                 NGX_HTTP_DISCARD_BUFFER_SIZE);

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

  811.         if (n == NGX_ERROR) {
  812.             r->connection->error = 1;
  813.             return NGX_OK;
  814.         }

  816.         if (n == NGX_AGAIN) {
  817.             return NGX_AGAIN;
  818.         }

  820.         if (n == 0) {
  821.             return NGX_OK;
  822.         }

  824.         b.pos = buffer;
  825.         b.last = buffer + n;

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

  829.         if (rc != NGX_OK) {
  830.             return rc;
  831.         }
  832.     }

  834.     if (ngx_http_copy_pipelined_header(r, &b) != NGX_OK) {
  835.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  836.     }

  838.     r->read_event_handler = ngx_http_block_reading;

  840.     return NGX_OK;
  841. }


  844. static ngx_int_t
  845. ‌ngx_http_discard_request_body_filter(ngx_http_request_t *r, ngx_buf_t *b)
  846. {
  847.     size_t                     size;
  848.     ngx_int_t                  rc;
  849.     ngx_http_request_body_t   *rb;
  850.     ngx_http_core_srv_conf_t  *cscf;

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

  854.         rb = r->request_body;

  856.         if (rb == NULL) {

  858.             rb = ngx_pcalloc(r->pool, sizeof(ngx_http_request_body_t));
  859.             if (rb == NULL) {
  860.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  861.             }

  863.             rb->chunked = ngx_pcalloc(r->pool, sizeof(ngx_http_chunked_t));
  864.             if (rb->chunked == NULL) {
  865.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  866.             }

  868.             r->request_body = rb;
  869.         }

  871.         for ( ;; ) {

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

  875.             if (rc == NGX_OK) {

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

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

  881.                 if ((off_t) size > rb->chunked->size) {
  882.                     b->pos += (size_t) rb->chunked->size;
  883.                     rb->chunked->size = 0;

  885.                 } else {
  886.                     rb->chunked->size -= size;
  887.                     b->pos = b->last;
  888.                 }

  890.                 continue;
  891.             }

  893.             if (rc == NGX_DONE) {

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

  897.                 r->headers_in.content_length_n = 0;
  898.                 break;
  899.             }

  901.             if (rc == NGX_AGAIN) {

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

  905.                 cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  907.                 r->headers_in.content_length_n = ngx_max(rb->chunked->length,
  908.                                (off_t) cscf->large_client_header_buffers.size);
  909.                 break;
  910.             }

  912.             /* invalid */

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

  917.             return NGX_HTTP_BAD_REQUEST;
  918.         }

  920.     } else {
  921.         size = b->last - b->pos;

  923.         if ((off_t) size > r->headers_in.content_length_n) {
  924.             b->pos += (size_t) r->headers_in.content_length_n;
  925.             r->headers_in.content_length_n = 0;

  927.         } else {
  928.             b->pos = b->last;
  929.             r->headers_in.content_length_n -= size;
  930.         }
  931.     }

  933.     return NGX_OK;
  934. }


  937. static ngx_int_t
  938. ‌ngx_http_test_expect(ngx_http_request_t *r)
  939. {
  940.     ngx_int_t   n;
  941.     ngx_str_t  *expect;

  943.     if (r->expect_tested
  944.         || r->headers_in.expect == NULL
  945.         || r->http_version < NGX_HTTP_VERSION_11
  946. #if (NGX_HTTP_V2)
  947.         || r->stream != NULL
  948. #endif
  949. #if (NGX_HTTP_V3)
  950.         || r->connection->quic != NULL
  951. #endif
  952.        )
  953.     {
  954.         return NGX_OK;
  955.     }

  957.     r->expect_tested = 1;

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

  961.     if (expect->len != sizeof("100-continue") - 1
  962.         || ngx_strncasecmp(expect->data, (u_char *) "100-continue",
  963.                            sizeof("100-continue") - 1)
  964.            != 0)
  965.     {
  966.         return NGX_OK;
  967.     }

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

  972.     n = r->connection->send(r->connection,
  973.                             (u_char *) "HTTP/1.1 100 Continue" CRLF CRLF,
  974.                             sizeof("HTTP/1.1 100 Continue" CRLF CRLF) - 1);

  976.     if (n == sizeof("HTTP/1.1 100 Continue" CRLF CRLF) - 1) {
  977.         return NGX_OK;
  978.     }

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

  982.     r->connection->error = 1;

  984.     return NGX_ERROR;
  985. }


  988. static ngx_int_t
  989. ‌ngx_http_request_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  990. {
  991.     if (r->headers_in.chunked) {
  992.         return ngx_http_request_body_chunked_filter(r, in);

  994.     } else {
  995.         return ngx_http_request_body_length_filter(r, in);
  996.     }
  997. }


  1000. static ngx_int_t
  1001. ‌ngx_http_request_body_length_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1002. {
  1003.     size_t                     size;
  1004.     ngx_int_t                  rc;
  1005.     ngx_buf_t                 *b;
  1006.     ngx_chain_t               *cl, *tl, *out, **ll;
  1007.     ngx_http_request_body_t   *rb;

  1009.     rb = r->request_body;

  1011.     out = NULL;
  1012.     ll = &out;

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

  1018.         rb->rest = r->headers_in.content_length_n;

  1020.         if (rb->rest == 0) {

  1022.             tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1023.             if (tl == NULL) {
  1024.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1025.             }

  1027.             b = tl->buf;

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

  1031.             b->last_buf = 1;

  1033.             *ll = tl;
  1034.             ll = &tl->next;
  1035.         }
  1036.     }

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

  1040.         if (rb->rest == 0) {
  1041.             break;
  1042.         }

  1044.         tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1045.         if (tl == NULL) {
  1046.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1047.         }

  1049.         b = tl->buf;

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

  1053.         b->temporary = 1;
  1054.         b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
  1055.         b->start = cl->buf->pos;
  1056.         b->pos = cl->buf->pos;
  1057.         b->last = cl->buf->last;
  1058.         b->end = cl->buf->end;
  1059.         b->flush = r->request_body_no_buffering;

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

  1063.         if ((off_t) size < rb->rest) {
  1064.             cl->buf->pos = cl->buf->last;
  1065.             rb->rest -= size;

  1067.         } else {
  1068.             cl->buf->pos += (size_t) rb->rest;
  1069.             rb->rest = 0;
  1070.             b->last = cl->buf->pos;
  1071.             b->last_buf = 1;
  1072.         }

  1074.         *ll = tl;
  1075.         ll = &tl->next;
  1076.     }

  1078.     rc = ngx_http_top_request_body_filter(r, out);

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

  1083.     return rc;
  1084. }


  1087. static ngx_int_t
  1088. ‌ngx_http_request_body_chunked_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1089. {
  1090.     size_t                     size;
  1091.     ngx_int_t                  rc;
  1092.     ngx_buf_t                 *b;
  1093.     ngx_chain_t               *cl, *out, *tl, **ll;
  1094.     ngx_http_request_body_t   *rb;
  1095.     ngx_http_core_loc_conf_t  *clcf;
  1096.     ngx_http_core_srv_conf_t  *cscf;

  1098.     rb = r->request_body;

  1100.     out = NULL;
  1101.     ll = &out;

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

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

  1108.         rb->chunked = ngx_pcalloc(r->pool, sizeof(ngx_http_chunked_t));
  1109.         if (rb->chunked == NULL) {
  1110.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1111.         }

  1113.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1115.         r->headers_in.content_length_n = 0;
  1116.         rb->rest = cscf->large_client_header_buffers.size;
  1117.     }

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

  1121.         b = NULL;

  1123.         for ( ;; ) {

  1125.             ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1126.                            "http body chunked buf "
  1127.                            "t:%d f:%d %p, pos %p, size: %z file: %O, size: %O",
  1128.                            cl->buf->temporary, cl->buf->in_file,
  1129.                            cl->buf->start, cl->buf->pos,
  1130.                            cl->buf->last - cl->buf->pos,
  1131.                            cl->buf->file_pos,
  1132.                            cl->buf->file_last - cl->buf->file_pos);

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

  1136.             if (rc == NGX_OK) {

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

  1140.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1142.                 if (clcf->client_max_body_size
  1143.                     && clcf->client_max_body_size
  1144.                        - r->headers_in.content_length_n < rb->chunked->size)
  1145.                 {
  1146.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1147.                                   "client intended to send too large chunked "
  1148.                                   "body: %O+%O bytes",
  1149.                                   r->headers_in.content_length_n,
  1150.                                   rb->chunked->size);

  1152.                     r->lingering_close = 1;

  1154.                     return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  1155.                 }

  1157.                 if (b
  1158.                     && rb->chunked->size <= 128
  1159.                     && cl->buf->last - cl->buf->pos >= rb->chunked->size)
  1160.                 {
  1161.                     r->headers_in.content_length_n += rb->chunked->size;

  1163.                     if (rb->chunked->size < 8) {

  1165.                         while (rb->chunked->size) {
  1166.                             *b->last++ = *cl->buf->pos++;
  1167.                             rb->chunked->size--;
  1168.                         }

  1170.                     } else {
  1171.                         ngx_memmove(b->last, cl->buf->pos, rb->chunked->size);
  1172.                         b->last += rb->chunked->size;
  1173.                         cl->buf->pos += rb->chunked->size;
  1174.                         rb->chunked->size = 0;
  1175.                     }

  1177.                     continue;
  1178.                 }

  1180.                 tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1181.                 if (tl == NULL) {
  1182.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1183.                 }

  1185.                 b = tl->buf;

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

  1189.                 b->temporary = 1;
  1190.                 b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
  1191.                 b->start = cl->buf->pos;
  1192.                 b->pos = cl->buf->pos;
  1193.                 b->last = cl->buf->last;
  1194.                 b->end = cl->buf->end;
  1195.                 b->flush = r->request_body_no_buffering;

  1197.                 *ll = tl;
  1198.                 ll = &tl->next;

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

  1202.                 if ((off_t) size > rb->chunked->size) {
  1203.                     cl->buf->pos += (size_t) rb->chunked->size;
  1204.                     r->headers_in.content_length_n += rb->chunked->size;
  1205.                     rb->chunked->size = 0;

  1207.                 } else {
  1208.                     rb->chunked->size -= size;
  1209.                     r->headers_in.content_length_n += size;
  1210.                     cl->buf->pos = cl->buf->last;
  1211.                 }

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

  1215.                 continue;
  1216.             }

  1218.             if (rc == NGX_DONE) {

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

  1222.                 rb->rest = 0;

  1224.                 tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1225.                 if (tl == NULL) {
  1226.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1227.                 }

  1229.                 b = tl->buf;

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

  1233.                 b->last_buf = 1;

  1235.                 *ll = tl;
  1236.                 ll = &tl->next;

  1238.                 break;
  1239.             }

  1241.             if (rc == NGX_AGAIN) {

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

  1245.                 cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1247.                 rb->rest = ngx_max(rb->chunked->length,
  1248.                                (off_t) cscf->large_client_header_buffers.size);

  1250.                 break;
  1251.             }

  1253.             /* invalid */

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

  1258.             return NGX_HTTP_BAD_REQUEST;
  1259.         }
  1260.     }

  1262.     rc = ngx_http_top_request_body_filter(r, out);

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

  1267.     return rc;
  1268. }


  1271. ngx_int_t
  1272. ‌ngx_http_request_body_save_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1273. {
  1274.     ngx_buf_t                 *b;
  1275.     ngx_chain_t               *cl, *tl, **ll;
  1276.     ngx_http_request_body_t   *rb;

  1278.     rb = r->request_body;

  1280.     ll = &rb->bufs;

  1282.     for (cl = rb->bufs; cl; cl = cl->next) {

  1284. #if 0
  1285.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1286.                        "http body old buf t:%d f:%d %p, pos %p, size: %z "
  1287.                        "file: %O, size: %O",
  1288.                        cl->buf->temporary, cl->buf->in_file,
  1289.                        cl->buf->start, cl->buf->pos,
  1290.                        cl->buf->last - cl->buf->pos,
  1291.                        cl->buf->file_pos,
  1292.                        cl->buf->file_last - cl->buf->file_pos);
  1293. #endif

  1295.         ll = &cl->next;
  1296.     }

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

  1300.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1301.                        "http body new buf t:%d f:%d %p, pos %p, size: %z "
  1302.                        "file: %O, size: %O",
  1303.                        cl->buf->temporary, cl->buf->in_file,
  1304.                        cl->buf->start, cl->buf->pos,
  1305.                        cl->buf->last - cl->buf->pos,
  1306.                        cl->buf->file_pos,
  1307.                        cl->buf->file_last - cl->buf->file_pos);

  1309.         if (cl->buf->last_buf) {

  1311.             if (rb->last_saved) {
  1312.                 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1313.                               "duplicate last buf in save filter");
  1314.                 *ll = NULL;
  1315.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1316.             }

  1318.             rb->last_saved = 1;
  1319.         }

  1321.         tl = ngx_alloc_chain_link(r->pool);
  1322.         if (tl == NULL) {
  1323.             *ll = NULL;
  1324.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1325.         }

  1327.         tl->buf = cl->buf;
  1328.         *ll = tl;
  1329.         ll = &tl->next;
  1330.     }

  1332.     *ll = NULL;

  1334.     if (r->request_body_no_buffering) {
  1335.         return NGX_OK;
  1336.     }

  1338.     if (rb->rest > 0) {

  1340.         if (rb->bufs && rb->buf && rb->buf->last == rb->buf->end
  1341.             && ngx_http_write_request_body(r) != NGX_OK)
  1342.         {
  1343.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1344.         }

  1346.         return NGX_OK;
  1347.     }

  1349.     if (!rb->last_saved) {
  1350.         return NGX_OK;
  1351.     }

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

  1355.         if (rb->bufs && rb->bufs->buf->in_file) {
  1356.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1357.                           "body already in file");
  1358.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1359.         }

  1361.         if (ngx_http_write_request_body(r) != NGX_OK) {
  1362.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1363.         }

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

  1367.             cl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1368.             if (cl == NULL) {
  1369.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1370.             }

  1372.             b = cl->buf;

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

  1376.             b->in_file = 1;
  1377.             b->file_last = rb->temp_file->file.offset;
  1378.             b->file = &rb->temp_file->file;

  1380.             rb->bufs = cl;
  1381.         }
  1382.     }

  1384.     return NGX_OK;
  1385. }

One Level Up Top Level