One Level Up Top Level

src/http/ngx_http_request_body.c - nginx

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.             || (!ngx_buf_in_memory(rb->bufs->buf) && rb->bufs->buf->last_buf))
  586.         {
  587.             /* empty body with r->request_body_in_file_only */

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

  596.             return NGX_OK;
  597.         }
  598.     }

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

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

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

  608.     if (n == NGX_ERROR) {
  609.         return NGX_ERROR;
  610.     }

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

  614.     /* mark all buffers as written */

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

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

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

  625.     rb->bufs = NULL;

  627.     return NGX_OK;
  628. }


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

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

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

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

  655.     if (ngx_http_test_expect(r) != NGX_OK) {
  656.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  657.     }

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

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

  663.     if (rev->timer_set) {
  664.         ngx_del_timer(rev);
  665.     }

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

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

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

  676.         if (rc != NGX_OK) {
  677.             return rc;
  678.         }

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

  685.     rc = ngx_http_read_discarded_request_body(r);

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

  692.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  693.         return rc;
  694.     }

  696.     /* rc == NGX_AGAIN */

  698.     r->read_event_handler = ngx_http_discarded_request_body_handler;

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

  704.     r->count++;
  705.     r->discard_body = 1;

  707.     return NGX_OK;
  708. }


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

  720.     c = r->connection;
  721.     rev = c->read;

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

  730.     if (r->lingering_time) {
  731.         timer = (ngx_msec_t) r->lingering_time - (ngx_msec_t) ngx_time();

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

  740.     } else {
  741.         timer = 0;
  742.     }

  744.     rc = ngx_http_read_discarded_request_body(r);

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

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

  760.     /* rc == NGX_AGAIN */

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

  768.     if (timer) {

  770.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  772.         timer *= 1000;

  774.         if (timer > clcf->lingering_timeout) {
  775.             timer = clcf->lingering_timeout;
  776.         }

  778.         ngx_add_timer(rev, timer);
  779.     }
  780. }


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

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

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

  797.     b.temporary = 1;

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

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

  808.         size = (size_t) ngx_min(r->headers_in.content_length_n,
  809.                                 NGX_HTTP_DISCARD_BUFFER_SIZE);

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

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

  818.         if (n == NGX_AGAIN) {
  819.             return NGX_AGAIN;
  820.         }

  822.         if (n == 0) {
  823.             return NGX_OK;
  824.         }

  826.         b.pos = buffer;
  827.         b.last = buffer + n;

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

  831.         if (rc != NGX_OK) {
  832.             return rc;
  833.         }
  834.     }

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

  840.     r->read_event_handler = ngx_http_block_reading;

  842.     return NGX_OK;
  843. }


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

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

  856.         rb = r->request_body;

  858.         if (rb == NULL) {

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

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

  870.             r->request_body = rb;
  871.         }

  873.         for ( ;; ) {

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

  877.             if (rc == NGX_OK) {

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

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

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

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

  892.                 continue;
  893.             }

  895.             if (rc == NGX_DONE) {

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

  899.                 r->headers_in.content_length_n = 0;
  900.                 break;
  901.             }

  903.             if (rc == NGX_AGAIN) {

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

  907.                 cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  914.             /* invalid */

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

  919.             return NGX_HTTP_BAD_REQUEST;
  920.         }

  922.     } else {
  923.         size = b->last - b->pos;

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

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

  935.     return NGX_OK;
  936. }


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

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

  959.     r->expect_tested = 1;

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

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

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

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

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

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

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

  986.     return NGX_ERROR;
  987. }


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

  996.     } else {
  997.         return ngx_http_request_body_length_filter(r, in);
  998.     }
  999. }


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

  1011.     rb = r->request_body;

  1013.     out = NULL;
  1014.     ll = &out;

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

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

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

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

  1029.             b = tl->buf;

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

  1033.             b->last_buf = 1;

  1035.             *ll = tl;
  1036.             ll = &tl->next;
  1037.         }
  1038.     }

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

  1042.         if (rb->rest == 0) {
  1043.             break;
  1044.         }

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

  1051.         b = tl->buf;

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

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

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

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

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

  1076.         *ll = tl;
  1077.         ll = &tl->next;
  1078.     }

  1080.     rc = ngx_http_top_request_body_filter(r, out);

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

  1085.     return rc;
  1086. }


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

  1100.     rb = r->request_body;

  1102.     out = NULL;
  1103.     ll = &out;

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

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

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

  1115.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

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

  1123.         b = NULL;

  1125.         for ( ;; ) {

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

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

  1138.             if (rc == NGX_OK) {

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

  1142.                 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1154.                     r->lingering_close = 1;

  1156.                     return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  1157.                 }

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

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

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

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

  1179.                     continue;
  1180.                 }

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

  1187.                 b = tl->buf;

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

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

  1199.                 *ll = tl;
  1200.                 ll = &tl->next;

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

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

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

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

  1217.                 continue;
  1218.             }

  1220.             if (rc == NGX_DONE) {

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

  1224.                 rb->rest = 0;

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

  1231.                 b = tl->buf;

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

  1235.                 b->last_buf = 1;

  1237.                 *ll = tl;
  1238.                 ll = &tl->next;

  1240.                 break;
  1241.             }

  1243.             if (rc == NGX_AGAIN) {

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

  1247.                 cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  1252.                 break;
  1253.             }

  1255.             /* invalid */

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

  1260.             return NGX_HTTP_BAD_REQUEST;
  1261.         }
  1262.     }

  1264.     rc = ngx_http_top_request_body_filter(r, out);

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

  1269.     return rc;
  1270. }


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

  1280.     rb = r->request_body;

  1282.     ll = &rb->bufs;

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

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

  1297.         ll = &cl->next;
  1298.     }

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

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

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

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

  1320.             rb->last_saved = 1;
  1321.         }

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

  1329.         tl->buf = cl->buf;
  1330.         *ll = tl;
  1331.         ll = &tl->next;
  1332.     }

  1334.     *ll = NULL;

  1336.     if (r->request_body_no_buffering) {
  1337.         return NGX_OK;
  1338.     }

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

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

  1348.         return NGX_OK;
  1349.     }

  1351.     if (!rb->last_saved) {
  1352.         return NGX_OK;
  1353.     }

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

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

  1363.         if (ngx_http_write_request_body(r) != NGX_OK) {
  1364.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1365.         }

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

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

  1374.             b = cl->buf;

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

  1378.             b->in_file = 1;
  1379.             b->file_last = rb->temp_file->file.offset;
  1380.             b->file = &rb->temp_file->file;

  1382.             rb->bufs = cl;
  1383.         }
  1384.     }

  1386.     return NGX_OK;
  1387. }

One Level Up Top Level