One Level Up Top Level

src/http/v3/ngx_http_v3_request.c - nginx-1.31.3 nginx/ @ 42f8df65b

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Roman Arutyunyan
  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_v3_init_request_stream(ngx_connection_t *c);
  14. static void ngx_http_v3_wait_request_handler(ngx_event_t *rev);
  15. static void ngx_http_v3_cleanup_connection(void *data);
  16. static void ngx_http_v3_cleanup_request(void *data);
  17. static void ngx_http_v3_process_request(ngx_event_t *rev);
  18. static ngx_int_t ngx_http_v3_process_header(ngx_http_request_t *r,
  19.     ngx_str_t *name, ngx_str_t *value);
  20. static ngx_int_t ngx_http_v3_validate_header(ngx_http_request_t *r,
  21.     ngx_str_t *name, ngx_str_t *value);
  22. static ngx_int_t ngx_http_v3_process_pseudo_header(ngx_http_request_t *r,
  23.     ngx_str_t *name, ngx_str_t *value);
  24. static ngx_int_t ngx_http_v3_init_pseudo_headers(ngx_http_request_t *r);
  25. static ngx_int_t ngx_http_v3_process_request_header(ngx_http_request_t *r);
  26. static ngx_int_t ngx_http_v3_cookie(ngx_http_request_t *r, ngx_str_t *value);
  27. static ngx_int_t ngx_http_v3_construct_cookie_header(ngx_http_request_t *r);
  28. static void ngx_http_v3_read_client_request_body_handler(ngx_http_request_t *r);
  29. static ngx_int_t ngx_http_v3_do_read_client_request_body(ngx_http_request_t *r);
  30. static ngx_int_t ngx_http_v3_request_body_filter(ngx_http_request_t *r,
  31.     ngx_chain_t *in);


  34. ‌static const struct {
  35.     ngx_str_t   name;
  36.     ngx_uint_t  method;
  37. ‌} ngx_http_v3_methods[] = {

  39.     { ngx_string("GET"),       NGX_HTTP_GET },
  40.     { ngx_string("POST"),      NGX_HTTP_POST },
  41.     { ngx_string("HEAD"),      NGX_HTTP_HEAD },
  42.     { ngx_string("OPTIONS"),   NGX_HTTP_OPTIONS },
  43.     { ngx_string("PROPFIND"),  NGX_HTTP_PROPFIND },
  44.     { ngx_string("PUT"),       NGX_HTTP_PUT },
  45.     { ngx_string("MKCOL"),     NGX_HTTP_MKCOL },
  46.     { ngx_string("DELETE"),    NGX_HTTP_DELETE },
  47.     { ngx_string("COPY"),      NGX_HTTP_COPY },
  48.     { ngx_string("MOVE"),      NGX_HTTP_MOVE },
  49.     { ngx_string("PROPPATCH"), NGX_HTTP_PROPPATCH },
  50.     { ngx_string("LOCK"),      NGX_HTTP_LOCK },
  51.     { ngx_string("UNLOCK"),    NGX_HTTP_UNLOCK },
  52.     { ngx_string("PATCH"),     NGX_HTTP_PATCH },
  53.     { ngx_string("TRACE"),     NGX_HTTP_TRACE },
  54.     { ngx_string("CONNECT"),   NGX_HTTP_CONNECT }
  55. };


  58. void
  59. ‌ngx_http_v3_init_stream(ngx_connection_t *c)
  60. {
  61.     ngx_http_connection_t     *hc, *phc;
  62.     ngx_http_v3_srv_conf_t    *h3scf;
  63.     ngx_http_core_loc_conf_t  *clcf;

  65.     hc = c->data;

  67.     hc->ssl = 1;

  69.     clcf = ngx_http_get_module_loc_conf(hc->conf_ctx, ngx_http_core_module);

  71.     if (c->quic == NULL) {
  72.         h3scf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_v3_module);
  73.         h3scf->quic.idle_timeout = clcf->keepalive_timeout;

  75.         ngx_quic_run(c, &h3scf->quic);
  76.         return;
  77.     }

  79.     phc = ngx_http_quic_get_connection(c);

  81.     if (phc->ssl_servername) {
  82.         hc->ssl_servername = phc->ssl_servername;
  83. #if (NGX_PCRE)
  84.         hc->ssl_servername_regex = phc->ssl_servername_regex;
  85. #endif
  86.         hc->conf_ctx = phc->conf_ctx;

  88.         ngx_set_connection_log(c, clcf->error_log);
  89.     }

  91.     if (c->quic->id & NGX_QUIC_STREAM_UNIDIRECTIONAL) {
  92.         ngx_http_v3_init_uni_stream(c);

  94.     } else  {
  95.         ngx_http_v3_init_request_stream(c);
  96.     }
  97. }


  100. ngx_int_t
  101. ‌ngx_http_v3_init(ngx_connection_t *c)
  102. {
  103.     unsigned int               len;
  104.     const unsigned char       *data;
  105.     ngx_http_v3_session_t     *h3c;
  106.     ngx_http_v3_srv_conf_t    *h3scf;
  107.     ngx_http_core_loc_conf_t  *clcf;

  109.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 init");

  111.     if (ngx_http_v3_init_session(c) != NGX_OK) {
  112.         return NGX_ERROR;
  113.     }

  115.     h3c = ngx_http_v3_get_session(c);
  116.     clcf = ngx_http_v3_get_module_loc_conf(c, ngx_http_core_module);
  117.     ngx_add_timer(&h3c->keepalive, clcf->keepalive_timeout);

  119.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  121.     if (h3scf->enable_hq) {
  122.         if (!h3scf->enable) {
  123.             h3c->hq = 1;
  124.             return NGX_OK;
  125.         }

  127.         SSL_get0_alpn_selected(c->ssl->connection, &data, &len);

  129.         if (len == sizeof(NGX_HTTP_V3_HQ_PROTO) - 1
  130.             && ngx_strncmp(data, NGX_HTTP_V3_HQ_PROTO, len) == 0)
  131.         {
  132.             h3c->hq = 1;
  133.             return NGX_OK;
  134.         }
  135.     }

  137.     if (ngx_http_v3_send_settings(c) != NGX_OK) {
  138.         return NGX_ERROR;
  139.     }

  141.     if (h3scf->max_table_capacity > 0) {
  142.         if (ngx_http_v3_get_uni_stream(c, NGX_HTTP_V3_STREAM_DECODER) == NULL) {
  143.             return NGX_ERROR;
  144.         }
  145.     }

  147.     return NGX_OK;
  148. }


  151. void
  152. ‌ngx_http_v3_shutdown(ngx_connection_t *c)
  153. {
  154.     ngx_http_v3_session_t  *h3c;

  156.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 shutdown");

  158.     h3c = ngx_http_v3_get_session(c);

  160.     if (h3c == NULL) {
  161.         ngx_quic_finalize_connection(c, NGX_HTTP_V3_ERR_NO_ERROR,
  162.                                      "connection shutdown");
  163.         return;
  164.     }

  166.     if (!h3c->goaway) {
  167.         h3c->goaway = 1;

  169.         if (!h3c->hq) {
  170.             (void) ngx_http_v3_send_goaway(c, h3c->next_request_id);
  171.         }

  173.         ngx_http_v3_shutdown_connection(c, NGX_HTTP_V3_ERR_NO_ERROR,
  174.                                         "connection shutdown");
  175.     }
  176. }


  179. static void
  180. ‌ngx_http_v3_init_request_stream(ngx_connection_t *c)
  181. {
  182.     uint64_t                   n;
  183.     ngx_event_t               *rev;
  184.     ngx_pool_cleanup_t        *cln;
  185.     ngx_http_connection_t     *hc;
  186.     ngx_http_v3_session_t     *h3c;
  187.     ngx_http_core_loc_conf_t  *clcf;
  188.     ngx_http_core_srv_conf_t  *cscf;

  190.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 init request stream");

  192. #if (NGX_STAT_STUB)
  193.     (void) ngx_atomic_fetch_add(ngx_stat_active, 1);
  194. #endif

  196.     hc = c->data;

  198.     clcf = ngx_http_get_module_loc_conf(hc->conf_ctx, ngx_http_core_module);

  200.     n = c->quic->id >> 2;

  202.     if (n >= clcf->keepalive_requests * 2) {
  203.         ngx_http_v3_finalize_connection(c, NGX_HTTP_V3_ERR_EXCESSIVE_LOAD,
  204.                                         "too many requests per connection");
  205.         ngx_http_close_connection(c);
  206.         return;
  207.     }

  209.     h3c = ngx_http_v3_get_session(c);

  211.     if (h3c->goaway) {
  212.         c->close = 1;
  213.         ngx_http_close_connection(c);
  214.         return;
  215.     }

  217.     h3c->next_request_id = c->quic->id + 0x04;

  219.     if (n + 1 == clcf->keepalive_requests
  220.         || ngx_current_msec - c->start_time > clcf->keepalive_time)
  221.     {
  222.         h3c->goaway = 1;

  224.         if (!h3c->hq) {
  225.             if (ngx_http_v3_send_goaway(c, h3c->next_request_id) != NGX_OK) {
  226.                 ngx_http_close_connection(c);
  227.                 return;
  228.             }
  229.         }

  231.         ngx_http_v3_shutdown_connection(c, NGX_HTTP_V3_ERR_NO_ERROR,
  232.                                         "reached maximum number of requests");
  233.     }

  235.     cln = ngx_pool_cleanup_add(c->pool, 0);
  236.     if (cln == NULL) {
  237.         ngx_http_close_connection(c);
  238.         return;
  239.     }

  241.     cln->handler = ngx_http_v3_cleanup_connection;
  242.     cln->data = c;

  244.     h3c->nrequests++;

  246.     if (h3c->keepalive.timer_set) {
  247.         ngx_del_timer(&h3c->keepalive);
  248.     }

  250.     rev = c->read;

  252.     if (!h3c->hq) {
  253.         rev->handler = ngx_http_v3_wait_request_handler;
  254.         c->write->handler = ngx_http_empty_handler;
  255.     }

  257.     if (rev->ready) {
  258.         rev->handler(rev);
  259.         return;
  260.     }

  262.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  264.     ngx_add_timer(rev, cscf->client_header_timeout);
  265.     ngx_reusable_connection(c, 1);

  267.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  268.         ngx_http_close_connection(c);
  269.         return;
  270.     }
  271. }


  274. static void
  275. ‌ngx_http_v3_wait_request_handler(ngx_event_t *rev)
  276. {
  277.     size_t                     size;
  278.     ssize_t                    n;
  279.     ngx_buf_t                 *b;
  280.     ngx_connection_t          *c;
  281.     ngx_pool_cleanup_t        *cln;
  282.     ngx_http_request_t        *r;
  283.     ngx_http_connection_t     *hc;
  284.     ngx_http_core_srv_conf_t  *cscf;

  286.     c = rev->data;

  288.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 wait request handler");

  290.     if (rev->timedout) {
  291.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  292.         c->timedout = 1;
  293.         ngx_http_close_connection(c);
  294.         return;
  295.     }

  297.     if (c->close) {
  298.         ngx_http_close_connection(c);
  299.         return;
  300.     }

  302.     hc = c->data;
  303.     cscf = ngx_http_get_module_srv_conf(hc->conf_ctx, ngx_http_core_module);

  305.     size = cscf->client_header_buffer_size;

  307.     b = c->buffer;

  309.     if (b == NULL) {
  310.         b = ngx_create_temp_buf(c->pool, size);
  311.         if (b == NULL) {
  312.             ngx_http_close_connection(c);
  313.             return;
  314.         }

  316.         c->buffer = b;

  318.     } else if (b->start == NULL) {

  320.         b->start = ngx_palloc(c->pool, size);
  321.         if (b->start == NULL) {
  322.             ngx_http_close_connection(c);
  323.             return;
  324.         }

  326.         b->pos = b->start;
  327.         b->last = b->start;
  328.         b->end = b->last + size;
  329.     }

  331.     n = c->recv(c, b->last, size);

  333.     if (n == NGX_AGAIN) {

  335.         if (!rev->timer_set) {
  336.             ngx_add_timer(rev, cscf->client_header_timeout);
  337.             ngx_reusable_connection(c, 1);
  338.         }

  340.         if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  341.             ngx_http_close_connection(c);
  342.             return;
  343.         }

  345.         /*
  346.          * We are trying to not hold c->buffer's memory for an idle connection.
  347.          */

  349.         if (ngx_pfree(c->pool, b->start) == NGX_OK) {
  350.             b->start = NULL;
  351.         }

  353.         return;
  354.     }

  356.     if (n == NGX_ERROR) {
  357.         ngx_http_close_connection(c);
  358.         return;
  359.     }

  361.     if (n == 0) {
  362.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  363.                       "client closed connection");
  364.         ngx_http_close_connection(c);
  365.         return;
  366.     }

  368.     b->last += n;

  370.     c->log->action = "reading client request";

  372.     ngx_reusable_connection(c, 0);

  374.     r = ngx_http_create_request(c);
  375.     if (r == NULL) {
  376.         ngx_http_close_connection(c);
  377.         return;
  378.     }

  380.     r->http_version = NGX_HTTP_VERSION_30;

  382.     r->v3_parse = ngx_pcalloc(r->pool, sizeof(ngx_http_v3_parse_t));
  383.     if (r->v3_parse == NULL) {
  384.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  385.         return;
  386.     }

  388.     r->v3_parse->header_limit = cscf->large_client_header_buffers.size
  389.                                 * cscf->large_client_header_buffers.num;

  391.     c->data = r;
  392.     c->requests = (c->quic->id >> 2) + 1;

  394.     cln = ngx_pool_cleanup_add(r->pool, 0);
  395.     if (cln == NULL) {
  396.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  397.         return;
  398.     }

  400.     cln->handler = ngx_http_v3_cleanup_request;
  401.     cln->data = r;

  403.     rev->handler = ngx_http_v3_process_request;
  404.     ngx_http_v3_process_request(rev);
  405. }


  408. void
  409. ‌ngx_http_v3_reset_stream(ngx_connection_t *c)
  410. {
  411.     ngx_http_v3_session_t  *h3c;

  413.     h3c = ngx_http_v3_get_session(c);

  415.     if (!c->read->eof && !h3c->hq
  416.         && h3c->known_streams[NGX_HTTP_V3_STREAM_SERVER_DECODER]
  417.         && (c->quic->id & NGX_QUIC_STREAM_UNIDIRECTIONAL) == 0)
  418.     {
  419.         (void) ngx_http_v3_send_cancel_stream(c, c->quic->id);
  420.     }

  422.     if (c->timedout) {
  423.         ngx_quic_reset_stream(c, NGX_HTTP_V3_ERR_GENERAL_PROTOCOL_ERROR);

  425.     } else if (c->close) {
  426.         ngx_quic_reset_stream(c, NGX_HTTP_V3_ERR_REQUEST_REJECTED);

  428.     } else if (c->requests == 0 || c->error) {
  429.         ngx_quic_reset_stream(c, NGX_HTTP_V3_ERR_INTERNAL_ERROR);
  430.     }
  431. }


  434. static void
  435. ‌ngx_http_v3_cleanup_connection(void *data)
  436. {
  437.     ngx_connection_t  *c = data;

  439.     ngx_http_v3_session_t     *h3c;
  440.     ngx_http_core_loc_conf_t  *clcf;

  442.     h3c = ngx_http_v3_get_session(c);

  444.     if (--h3c->nrequests == 0) {
  445.         clcf = ngx_http_v3_get_module_loc_conf(c, ngx_http_core_module);
  446.         ngx_add_timer(&h3c->keepalive, clcf->keepalive_timeout);
  447.     }
  448. }


  451. static void
  452. ‌ngx_http_v3_cleanup_request(void *data)
  453. {
  454.     ngx_http_request_t  *r = data;

  456.     if (!r->response_sent) {
  457.         r->connection->error = 1;
  458.     }
  459. }


  462. static void
  463. ‌ngx_http_v3_process_request(ngx_event_t *rev)
  464. {
  465.     u_char                       *p;
  466.     ssize_t                       n;
  467.     ngx_buf_t                    *b;
  468.     ngx_int_t                     rc;
  469.     ngx_connection_t             *c;
  470.     ngx_http_request_t           *r;
  471.     ngx_http_v3_session_t        *h3c;
  472.     ngx_http_core_srv_conf_t     *cscf;
  473.     ngx_http_v3_parse_headers_t  *st;

  475.     c = rev->data;
  476.     r = c->data;

  478.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, rev->log, 0, "http3 process request");

  480.     if (rev->timedout) {
  481.         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT, "client timed out");
  482.         c->timedout = 1;
  483.         ngx_http_close_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  484.         return;
  485.     }

  487.     h3c = ngx_http_v3_get_session(c);

  489.     st = &r->v3_parse->headers;

  491.     b = r->header_in;

  493.     for ( ;; ) {

  495.         if (b->pos == b->last) {

  497.             if (rev->ready) {
  498.                 n = c->recv(c, b->start, b->end - b->start);

  500.             } else {
  501.                 n = NGX_AGAIN;
  502.             }

  504.             if (n == NGX_AGAIN) {
  505.                 if (!rev->timer_set) {
  506.                     cscf = ngx_http_get_module_srv_conf(r,
  507.                                                         ngx_http_core_module);
  508.                     ngx_add_timer(rev, cscf->client_header_timeout);
  509.                 }

  511.                 if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  512.                     ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  513.                 }

  515.                 break;
  516.             }

  518.             if (n == 0) {
  519.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  520.                               "client prematurely closed connection");
  521.             }

  523.             if (n == 0 || n == NGX_ERROR) {
  524.                 c->error = 1;
  525.                 c->log->action = "reading client request";

  527.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  528.                 break;
  529.             }

  531.             b->pos = b->start;
  532.             b->last = b->start + n;
  533.         }

  535.         p = b->pos;

  537.         rc = ngx_http_v3_parse_headers(c, st, b);

  539.         if (rc > 0) {
  540.             ngx_quic_reset_stream(c, rc);
  541.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  542.                           "client sent invalid header");
  543.             ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  544.             break;
  545.         }

  547.         if (rc == NGX_ERROR) {
  548.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  549.             break;
  550.         }

  552.         r->request_length += b->pos - p;
  553.         h3c->total_bytes += b->pos - p;

  555.         if (ngx_http_v3_check_flood(c) != NGX_OK) {
  556.             ngx_http_close_request(r, NGX_HTTP_CLOSE);
  557.             break;
  558.         }

  560.         if (rc == NGX_BUSY) {
  561.             if (rev->error) {
  562.                 ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  563.                 break;
  564.             }

  566.             if (!rev->timer_set) {
  567.                 cscf = ngx_http_get_module_srv_conf(r,
  568.                                                     ngx_http_core_module);
  569.                 ngx_add_timer(rev, cscf->client_header_timeout);
  570.             }

  572.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  573.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  574.             }

  576.             break;
  577.         }

  579.         if (rc == NGX_AGAIN) {
  580.             continue;
  581.         }

  583.         /* rc == NGX_OK || rc == NGX_DONE */

  585.         h3c->payload_bytes += ngx_http_v3_encode_field_l(NULL,
  586.                                                    &st->field_rep.field.name,
  587.                                                    &st->field_rep.field.value);

  589.         if (ngx_http_v3_process_header(r, &st->field_rep.field.name,
  590.                                        &st->field_rep.field.value)
  591.             != NGX_OK)
  592.         {
  593.             break;
  594.         }

  596.         if (rc == NGX_DONE) {
  597.             if (ngx_http_v3_process_request_header(r) != NGX_OK) {
  598.                 break;
  599.             }

  601.             ngx_http_process_request(r);
  602.             break;
  603.         }
  604.     }

  606.     ngx_http_run_posted_requests(c);

  608.     return;
  609. }


  612. static ngx_int_t
  613. ‌ngx_http_v3_process_header(ngx_http_request_t *r, ngx_str_t *name,
  614.     ngx_str_t *value)
  615. {
  616.     size_t                      len;
  617.     ngx_table_elt_t            *h;
  618.     ngx_http_header_t          *hh;
  619.     ngx_http_core_srv_conf_t   *cscf;
  620.     ngx_http_core_main_conf_t  *cmcf;

  622.     static ngx_str_t cookie = ngx_string("cookie");

  624.     len = name->len + value->len;

  626.     if (len > r->v3_parse->header_limit) {
  627.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  628.                       "client sent too large header");
  629.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  630.         return NGX_ERROR;
  631.     }

  633.     r->v3_parse->header_limit -= len;

  635.     if (ngx_http_v3_validate_header(r, name, value) != NGX_OK) {
  636.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  637.         return NGX_ERROR;
  638.     }

  640.     if (r->invalid_header) {
  641.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  643.         if (cscf->ignore_invalid_headers) {
  644.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  645.                           "client sent invalid header: \"%V\"", name);

  647.             return NGX_OK;
  648.         }
  649.     }

  651.     if (name->len && name->data[0] == ':') {
  652.         return ngx_http_v3_process_pseudo_header(r, name, value);
  653.     }

  655.     if (ngx_http_v3_init_pseudo_headers(r) != NGX_OK) {
  656.         return NGX_ERROR;
  657.     }

  659.     if (name->len == cookie.len
  660.         && ngx_memcmp(name->data, cookie.data, cookie.len) == 0)
  661.     {
  662.         if (ngx_http_v3_cookie(r, value) != NGX_OK) {
  663.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  664.             return NGX_ERROR;
  665.         }

  667.     } else {
  668.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  670.         if (r->headers_in.count++ >= cscf->max_headers) {
  671.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  672.                           "client sent too many header lines");
  673.             ngx_http_finalize_request(r, NGX_HTTP_REQUEST_HEADER_TOO_LARGE);
  674.             return NGX_ERROR;
  675.         }

  677.         h = ngx_list_push(&r->headers_in.headers);
  678.         if (h == NULL) {
  679.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  680.             return NGX_ERROR;
  681.         }

  683.         h->key = *name;
  684.         h->value = *value;
  685.         h->lowcase_key = h->key.data;
  686.         h->hash = ngx_hash_key(h->key.data, h->key.len);

  688.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  690.         hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash,
  691.                            h->lowcase_key, h->key.len);

  693.         if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  694.             return NGX_ERROR;
  695.         }
  696.     }

  698.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  699.                    "http3 header: \"%V: %V\"", name, value);
  700.     return NGX_OK;
  701. }


  704. static ngx_int_t
  705. ‌ngx_http_v3_validate_header(ngx_http_request_t *r, ngx_str_t *name,
  706.     ngx_str_t *value)
  707. {
  708.     u_char                     ch;
  709.     ngx_uint_t                 i;
  710.     ngx_http_core_srv_conf_t  *cscf;

  712.     r->invalid_header = 0;

  714.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  716.     for (i = (name->data[0] == ':'); i != name->len; i++) {
  717.         ch = name->data[i];

  719.         if ((ch >= 'a' && ch <= 'z')
  720.             || (ch == '-')
  721.             || (ch >= '0' && ch <= '9')
  722.             || (ch == '_' && cscf->underscores_in_headers))
  723.         {
  724.             continue;
  725.         }

  727.         if (ch <= 0x20 || ch == 0x7f || ch == ':'
  728.             || (ch >= 'A' && ch <= 'Z'))
  729.         {
  730.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  731.                           "client sent invalid header name: \"%V\"", name);

  733.             return NGX_ERROR;
  734.         }

  736.         r->invalid_header = 1;
  737.     }

  739.     for (i = 0; i != value->len; i++) {
  740.         ch = value->data[i];

  742.         if (ch == '\0' || ch == LF || ch == CR) {
  743.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  744.                           "client sent header \"%V\" with "
  745.                           "invalid value: \"%V\"", name, value);

  747.             return NGX_ERROR;
  748.         }
  749.     }

  751.     return NGX_OK;
  752. }


  755. static ngx_int_t
  756. ‌ngx_http_v3_process_pseudo_header(ngx_http_request_t *r, ngx_str_t *name,
  757.     ngx_str_t *value)
  758. {
  759.     u_char      ch, c;
  760.     ngx_uint_t  i;

  762.     if (r->request_line.len) {
  763.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  764.                       "client sent out of order pseudo-headers");
  765.         goto failed;
  766.     }

  768.     if (name->len == 7 && ngx_strncmp(name->data, ":method", 7) == 0) {

  770.         if (r->method_name.len) {
  771.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  772.                           "client sent duplicate \":method\" header");
  773.             goto failed;
  774.         }

  776.         if (value->len == 0) {
  777.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  778.                           "client sent empty \":method\" header");
  779.             goto failed;
  780.         }

  782.         r->method_name = *value;

  784.         for (i = 0; i < sizeof(ngx_http_v3_methods)
  785.                         / sizeof(ngx_http_v3_methods[0]); i++)
  786.         {
  787.             if (value->len == ngx_http_v3_methods[i].name.len
  788.                 && ngx_strncmp(value->data,
  789.                                ngx_http_v3_methods[i].name.data, value->len)
  790.                    == 0)
  791.             {
  792.                 r->method = ngx_http_v3_methods[i].method;
  793.                 break;
  794.             }
  795.         }

  797.         for (i = 0; i < value->len; i++) {
  798.             ch = value->data[i];

  800.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  801.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  802.                               "client sent invalid method: \"%V\"", value);
  803.                 goto failed;
  804.             }
  805.         }

  807.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  808.                        "http3 method \"%V\" %ui", value, r->method);
  809.         return NGX_OK;
  810.     }

  812.     if (name->len == 5 && ngx_strncmp(name->data, ":path", 5) == 0) {

  814.         if (r->uri_start) {
  815.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  816.                           "client sent duplicate \":path\" header");
  817.             goto failed;
  818.         }

  820.         if (value->len == 0) {
  821.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  822.                           "client sent empty \":path\" header");
  823.             goto failed;
  824.         }

  826.         r->uri_start = value->data;
  827.         r->uri_end = value->data + value->len;

  829.         if (ngx_http_parse_uri(r) != NGX_OK) {
  830.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  831.                           "client sent invalid \":path\" header: \"%V\"",
  832.                           value);
  833.             goto failed;
  834.         }

  836.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  837.                        "http3 path \"%V\"", value);
  838.         return NGX_OK;
  839.     }

  841.     if (name->len == 7 && ngx_strncmp(name->data, ":scheme", 7) == 0) {

  843.         if (r->schema.len) {
  844.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  845.                           "client sent duplicate \":scheme\" header");
  846.             goto failed;
  847.         }

  849.         if (value->len == 0) {
  850.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  851.                           "client sent empty \":scheme\" header");
  852.             goto failed;
  853.         }

  855.         for (i = 0; i < value->len; i++) {
  856.             ch = value->data[i];

  858.             c = (u_char) (ch | 0x20);
  859.             if (c >= 'a' && c <= 'z') {
  860.                 continue;
  861.             }

  863.             if (((ch >= '0' && ch <= '9')
  864.                  || ch == '+' || ch == '-' || ch == '.')
  865.                 && i > 0)
  866.             {
  867.                 continue;
  868.             }

  870.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  871.                           "client sent invalid \":scheme\" header: \"%V\"",
  872.                           value);
  873.             goto failed;
  874.         }

  876.         r->schema = *value;

  878.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  879.                        "http3 schema \"%V\"", value);
  880.         return NGX_OK;
  881.     }

  883.     if (name->len == 10 && ngx_strncmp(name->data, ":authority", 10) == 0) {

  885.         if (r->host_start) {
  886.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  887.                           "client sent duplicate \":authority\" header");
  888.             goto failed;
  889.         }

  891.         r->host_start = value->data;
  892.         r->host_end = value->data + value->len;

  894.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  895.                        "http3 authority \"%V\"", value);
  896.         return NGX_OK;
  897.     }

  899.     ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  900.                   "client sent unknown pseudo-header \"%V\"", name);

  902. failed:

  904.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  905.     return NGX_ERROR;
  906. }


  909. static ngx_int_t
  910. ‌ngx_http_v3_init_pseudo_headers(ngx_http_request_t *r)
  911. {
  912.     size_t      len;
  913.     u_char     *p;
  914.     ngx_int_t   rc;
  915.     ngx_str_t   host;
  916.     in_port_t   port;

  918.     if (r->request_line.len) {
  919.         return NGX_OK;
  920.     }

  922.     if (r->method_name.len == 0) {
  923.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  924.                       "client sent no \":method\" header");
  925.         goto failed;
  926.     }

  928.     if (r->schema.len == 0) {
  929.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  930.                       "client sent no \":scheme\" header");
  931.         goto failed;
  932.     }

  934.     if (r->uri_start == NULL) {
  935.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  936.                       "client sent no \":path\" header");
  937.         goto failed;
  938.     }

  940.     len = r->method_name.len + 1
  941.           + (r->uri_end - r->uri_start) + 1
  942.           + sizeof("HTTP/3.0") - 1;

  944.     p = ngx_pnalloc(r->pool, len);
  945.     if (p == NULL) {
  946.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  947.         return NGX_ERROR;
  948.     }

  950.     r->request_line.data = p;

  952.     p = ngx_cpymem(p, r->method_name.data, r->method_name.len);
  953.     *p++ = ' ';
  954.     p = ngx_cpymem(p, r->uri_start, r->uri_end - r->uri_start);
  955.     *p++ = ' ';
  956.     p = ngx_cpymem(p, "HTTP/3.0", sizeof("HTTP/3.0") - 1);

  958.     r->request_line.len = p - r->request_line.data;

  960.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  961.                    "http3 request line: \"%V\"", &r->request_line);

  963.     ngx_str_set(&r->http_protocol, "HTTP/3.0");

  965.     if (ngx_http_process_request_uri(r) != NGX_OK) {
  966.         return NGX_ERROR;
  967.     }

  969.     if (r->host_end) {

  971.         host.len = r->host_end - r->host_start;
  972.         host.data = r->host_start;

  974.         rc = ngx_http_validate_host(&host, &port, r->pool, 0);

  976.         if (rc == NGX_DECLINED) {
  977.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  978.                           "client sent invalid \":authority\" header");
  979.             goto failed;
  980.         }

  982.         if (rc == NGX_ERROR) {
  983.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  984.             return NGX_ERROR;
  985.         }

  987.         if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  988.             return NGX_ERROR;
  989.         }

  991.         r->headers_in.server = host;
  992.         r->port = port;
  993.     }

  995.     if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  996.                       sizeof(ngx_table_elt_t))
  997.         != NGX_OK)
  998.     {
  999.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1000.         return NGX_ERROR;
  1001.     }

  1003.     return NGX_OK;

  1005. failed:

  1007.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1008.     return NGX_ERROR;
  1009. }


  1012. static ngx_int_t
  1013. ‌ngx_http_v3_process_request_header(ngx_http_request_t *r)
  1014. {
  1015.     ssize_t                  n;
  1016.     ngx_buf_t               *b;
  1017.     ngx_str_t                host;
  1018.     ngx_connection_t        *c;
  1019.     ngx_http_v3_session_t   *h3c;
  1020.     ngx_http_v3_srv_conf_t  *h3scf;

  1022.     c = r->connection;

  1024.     if (r->headers_in.connection) {
  1025.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1026.                       "client sent \"Connection\" header");
  1027.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1028.         return NGX_ERROR;
  1029.     }

  1031.     if (r->headers_in.keep_alive) {
  1032.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1033.                       "client sent \"Keep-Alive\" header");
  1034.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1035.         return NGX_ERROR;
  1036.     }

  1038.     if (r->headers_in.transfer_encoding) {
  1039.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1040.                       "client sent \"Transfer-Encoding\" header");
  1041.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1042.         return NGX_ERROR;
  1043.     }

  1045.     if (r->headers_in.upgrade) {
  1046.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1047.                       "client sent \"Upgrade\" header");
  1048.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1049.         return NGX_ERROR;
  1050.     }

  1052.     if (r->headers_in.te
  1053.         && (r->headers_in.te->next
  1054.             || r->headers_in.te->value.len != 8
  1055.             || ngx_strncasecmp(r->headers_in.te->value.data,
  1056.                                (u_char *) "trailers", 8) != 0))
  1057.     {
  1058.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1059.                       "client sent invalid \"TE\" header");
  1060.         ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1061.         return NGX_ERROR;
  1062.     }

  1064.     if (ngx_http_v3_init_pseudo_headers(r) != NGX_OK) {
  1065.         return NGX_ERROR;
  1066.     }

  1068.     h3c = ngx_http_v3_get_session(c);
  1069.     h3scf = ngx_http_get_module_srv_conf(r, ngx_http_v3_module);

  1071.     if ((h3c->hq && !h3scf->enable_hq) || (!h3c->hq && !h3scf->enable)) {
  1072.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1073.                       "client attempted to request the server name "
  1074.                       "for which the negotiated protocol is disabled");
  1075.         ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  1076.         return NGX_ERROR;
  1077.     }

  1079.     if (ngx_http_v3_construct_cookie_header(r) != NGX_OK) {
  1080.         return NGX_ERROR;
  1081.     }

  1083.     if (r->headers_in.server.len == 0) {
  1084.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1085.                       "client sent neither \":authority\" nor \"Host\" header");
  1086.         goto failed;
  1087.     }

  1089.     if (r->headers_in.host && r->host_end) {

  1091.         host.len = r->host_end - r->host_start;
  1092.         host.data = r->host_start;

  1094.         if (r->headers_in.host->value.len != host.len
  1095.             || ngx_memcmp(r->headers_in.host->value.data, host.data, host.len)
  1096.                != 0)
  1097.         {
  1098.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1099.                           "client sent \":authority\" and \"Host\" headers "
  1100.                           "with different values");
  1101.             goto failed;
  1102.         }
  1103.     }

  1105.     if (r->headers_in.content_length) {
  1106.         r->headers_in.content_length_n =
  1107.                             ngx_atoof(r->headers_in.content_length->value.data,
  1108.                                       r->headers_in.content_length->value.len);

  1110.         if (r->headers_in.content_length_n == NGX_ERROR) {
  1111.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1112.                           "client sent invalid \"Content-Length\" header");
  1113.             goto failed;
  1114.         }

  1116.     } else {
  1117.         b = r->header_in;
  1118.         n = b->last - b->pos;

  1120.         if (n == 0) {
  1121.             n = c->recv(c, b->start, b->end - b->start);

  1123.             if (n == NGX_ERROR) {
  1124.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1125.                 return NGX_ERROR;
  1126.             }

  1128.             if (n > 0) {
  1129.                 b->pos = b->start;
  1130.                 b->last = b->start + n;
  1131.             }
  1132.         }

  1134.         if (n != 0) {
  1135.             r->headers_in.chunked = 1;
  1136.         }
  1137.     }

  1139.     if (r->method == NGX_HTTP_CONNECT) {
  1140.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent CONNECT method");
  1141.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  1142.         return NGX_ERROR;
  1143.     }

  1145.     if (r->method == NGX_HTTP_TRACE) {
  1146.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent TRACE method");
  1147.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  1148.         return NGX_ERROR;
  1149.     }

  1151.     return NGX_OK;

  1153. failed:

  1155.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1156.     return NGX_ERROR;
  1157. }


  1160. static ngx_int_t
  1161. ‌ngx_http_v3_cookie(ngx_http_request_t *r, ngx_str_t *value)
  1162. {
  1163.     ngx_str_t    *val;
  1164.     ngx_array_t  *cookies;

  1166.     cookies = r->v3_parse->cookies;

  1168.     if (cookies == NULL) {
  1169.         cookies = ngx_array_create(r->pool, 2, sizeof(ngx_str_t));
  1170.         if (cookies == NULL) {
  1171.             return NGX_ERROR;
  1172.         }

  1174.         r->v3_parse->cookies = cookies;
  1175.     }

  1177.     val = ngx_array_push(cookies);
  1178.     if (val == NULL) {
  1179.         return NGX_ERROR;
  1180.     }

  1182.     *val = *value;

  1184.     return NGX_OK;
  1185. }


  1188. static ngx_int_t
  1189. ‌ngx_http_v3_construct_cookie_header(ngx_http_request_t *r)
  1190. {
  1191.     u_char                     *buf, *p, *end;
  1192.     size_t                      len;
  1193.     ngx_str_t                  *vals;
  1194.     ngx_uint_t                  i;
  1195.     ngx_array_t                *cookies;
  1196.     ngx_table_elt_t            *h;
  1197.     ngx_http_header_t          *hh;
  1198.     ngx_http_core_main_conf_t  *cmcf;

  1200.     static ngx_str_t cookie = ngx_string("cookie");

  1202.     cookies = r->v3_parse->cookies;

  1204.     if (cookies == NULL) {
  1205.         return NGX_OK;
  1206.     }

  1208.     vals = cookies->elts;

  1210.     i = 0;
  1211.     len = 0;

  1213.     do {
  1214.         len += vals[i].len + 2;
  1215.     } while (++i != cookies->nelts);

  1217.     len -= 2;

  1219.     buf = ngx_pnalloc(r->pool, len + 1);
  1220.     if (buf == NULL) {
  1221.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1222.         return NGX_ERROR;
  1223.     }

  1225.     p = buf;
  1226.     end = buf + len;

  1228.     for (i = 0; /* void */ ; i++) {

  1230.         p = ngx_cpymem(p, vals[i].data, vals[i].len);

  1232.         if (p == end) {
  1233.             *p = '\0';
  1234.             break;
  1235.         }

  1237.         *p++ = ';'; *p++ = ' ';
  1238.     }

  1240.     h = ngx_list_push(&r->headers_in.headers);
  1241.     if (h == NULL) {
  1242.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1243.         return NGX_ERROR;
  1244.     }

  1246.     h->hash = ngx_hash(ngx_hash(ngx_hash(ngx_hash(
  1247.                                     ngx_hash('c', 'o'), 'o'), 'k'), 'i'), 'e');

  1249.     h->key.len = cookie.len;
  1250.     h->key.data = cookie.data;

  1252.     h->value.len = len;
  1253.     h->value.data = buf;

  1255.     h->lowcase_key = cookie.data;

  1257.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1259.     hh = ngx_hash_find(&cmcf->headers_in_hash, h->hash,
  1260.                        h->lowcase_key, h->key.len);

  1262.     if (hh == NULL) {
  1263.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1264.         return NGX_ERROR;
  1265.     }

  1267.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  1268.         /*
  1269.          * request has been finalized already
  1270.          * in ngx_http_process_header_line()
  1271.          */
  1272.         return NGX_ERROR;
  1273.     }

  1275.     return NGX_OK;
  1276. }


  1279. ngx_int_t
  1280. ‌ngx_http_v3_read_request_body(ngx_http_request_t *r)
  1281. {
  1282.     size_t                     preread;
  1283.     ngx_int_t                  rc;
  1284.     ngx_chain_t               *cl, out;
  1285.     ngx_http_request_body_t   *rb;
  1286.     ngx_http_core_loc_conf_t  *clcf;

  1288.     rb = r->request_body;

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

  1292.     if (preread) {

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

  1296.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1297.                        "http3 client request body preread %uz", preread);

  1299.         out.buf = r->header_in;
  1300.         out.next = NULL;
  1301.         cl = &out;

  1303.     } else {
  1304.         cl = NULL;
  1305.     }

  1307.     rc = ngx_http_v3_request_body_filter(r, cl);
  1308.     if (rc != NGX_OK) {
  1309.         return rc;
  1310.     }

  1312.     if (rb->rest == 0 && rb->last_saved) {
  1313.         /* the whole request body was pre-read */
  1314.         r->request_body_no_buffering = 0;
  1315.         rb->post_handler(r);
  1316.         return NGX_OK;
  1317.     }

  1319.     if (rb->rest < 0) {
  1320.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1321.                       "negative request body rest");
  1322.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1323.     }

  1325.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1327.     rb->buf = ngx_create_temp_buf(r->pool, clcf->client_body_buffer_size);
  1328.     if (rb->buf == NULL) {
  1329.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1330.     }

  1332.     r->read_event_handler = ngx_http_v3_read_client_request_body_handler;
  1333.     r->write_event_handler = ngx_http_request_empty_handler;

  1335.     return ngx_http_v3_do_read_client_request_body(r);
  1336. }


  1339. static void
  1340. ‌ngx_http_v3_read_client_request_body_handler(ngx_http_request_t *r)
  1341. {
  1342.     ngx_int_t  rc;

  1344.     if (r->connection->read->timedout) {
  1345.         r->connection->timedout = 1;
  1346.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1347.         return;
  1348.     }

  1350.     rc = ngx_http_v3_do_read_client_request_body(r);

  1352.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  1353.         ngx_http_finalize_request(r, rc);
  1354.     }
  1355. }


  1358. ngx_int_t
  1359. ‌ngx_http_v3_read_unbuffered_request_body(ngx_http_request_t *r)
  1360. {
  1361.     ngx_int_t  rc;

  1363.     if (r->connection->read->timedout) {
  1364.         r->connection->timedout = 1;
  1365.         return NGX_HTTP_REQUEST_TIME_OUT;
  1366.     }

  1368.     rc = ngx_http_v3_do_read_client_request_body(r);

  1370.     if (rc == NGX_OK) {
  1371.         r->reading_body = 0;
  1372.     }

  1374.     return rc;
  1375. }


  1378. static ngx_int_t
  1379. ‌ngx_http_v3_do_read_client_request_body(ngx_http_request_t *r)
  1380. {
  1381.     off_t                      rest;
  1382.     size_t                     size;
  1383.     ssize_t                    n;
  1384.     ngx_int_t                  rc;
  1385.     ngx_uint_t                 flush;
  1386.     ngx_chain_t                out;
  1387.     ngx_connection_t          *c;
  1388.     ngx_http_request_body_t   *rb;
  1389.     ngx_http_core_loc_conf_t  *clcf;

  1391.     c = r->connection;
  1392.     rb = r->request_body;
  1393.     flush = 1;

  1395.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1396.                    "http3 read client request body");

  1398.     for ( ;; ) {
  1399.         for ( ;; ) {
  1400.             if (rb->rest == 0) {
  1401.                 break;
  1402.             }

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

  1406.                 /* update chains */

  1408.                 rc = ngx_http_v3_request_body_filter(r, NULL);

  1410.                 if (rc != NGX_OK) {
  1411.                     return rc;
  1412.                 }

  1414.                 if (rb->busy != NULL) {
  1415.                     if (r->request_body_no_buffering) {
  1416.                         if (c->read->timer_set) {
  1417.                             ngx_del_timer(c->read);
  1418.                         }

  1420.                         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1421.                             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1422.                         }

  1424.                         return NGX_AGAIN;
  1425.                     }

  1427.                     if (rb->filter_need_buffering) {
  1428.                         clcf = ngx_http_get_module_loc_conf(r,
  1429.                                                          ngx_http_core_module);
  1430.                         ngx_add_timer(c->read, clcf->client_body_timeout);

  1432.                         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1433.                             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1434.                         }

  1436.                         return NGX_AGAIN;
  1437.                     }

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

  1442.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1443.                 }

  1445.                 flush = 0;
  1446.                 rb->buf->pos = rb->buf->start;
  1447.                 rb->buf->last = rb->buf->start;
  1448.             }

  1450.             size = rb->buf->end - rb->buf->last;
  1451.             rest = rb->rest - (rb->buf->last - rb->buf->pos);

  1453.             if ((off_t) size > rest) {
  1454.                 size = (size_t) rest;
  1455.             }

  1457.             if (size == 0) {
  1458.                 break;
  1459.             }

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

  1463.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1464.                            "http3 client request body recv %z", n);

  1466.             if (n == NGX_AGAIN) {
  1467.                 break;
  1468.             }

  1470.             if (n == 0) {
  1471.                 rb->buf->last_buf = 1;
  1472.             }

  1474.             if (n == NGX_ERROR) {
  1475.                 c->error = 1;
  1476.                 return NGX_HTTP_BAD_REQUEST;
  1477.             }

  1479.             rb->buf->last += n;

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

  1483.             flush = 0;
  1484.             out.buf = rb->buf;
  1485.             out.next = NULL;

  1487.             rc = ngx_http_v3_request_body_filter(r, &out);

  1489.             if (rc != NGX_OK) {
  1490.                 return rc;
  1491.             }

  1493.             if (rb->rest == 0) {
  1494.                 break;
  1495.             }

  1497.             if (rb->buf->last < rb->buf->end) {
  1498.                 break;
  1499.             }
  1500.         }

  1502.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1503.                        "http3 client request body rest %O", rb->rest);

  1505.         if (flush) {
  1506.             rc = ngx_http_v3_request_body_filter(r, NULL);

  1508.             if (rc != NGX_OK) {
  1509.                 return rc;
  1510.             }
  1511.         }

  1513.         if (rb->rest == 0 && rb->last_saved) {
  1514.             break;
  1515.         }

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

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

  1522.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1523.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1524.             }

  1526.             return NGX_AGAIN;
  1527.         }
  1528.     }

  1530.     if (c->read->timer_set) {
  1531.         ngx_del_timer(c->read);
  1532.     }

  1534.     if (!r->request_body_no_buffering) {
  1535.         r->read_event_handler = ngx_http_block_reading;
  1536.         rb->post_handler(r);
  1537.     }

  1539.     return NGX_OK;
  1540. }


  1543. static ngx_int_t
  1544. ‌ngx_http_v3_request_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1545. {
  1546.     off_t                      max;
  1547.     size_t                     size;
  1548.     u_char                    *p;
  1549.     ngx_int_t                  rc;
  1550.     ngx_buf_t                 *b;
  1551.     ngx_uint_t                 last;
  1552.     ngx_chain_t               *cl, *out, *tl, **ll;
  1553.     ngx_http_v3_session_t     *h3c;
  1554.     ngx_http_request_body_t   *rb;
  1555.     ngx_http_core_loc_conf_t  *clcf;
  1556.     ngx_http_core_srv_conf_t  *cscf;
  1557.     ngx_http_v3_parse_data_t  *st;

  1559.     rb = r->request_body;
  1560.     st = &r->v3_parse->body;

  1562.     h3c = ngx_http_v3_get_session(r->connection);

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

  1566.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1567.                        "http3 request body filter");

  1569.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1571.         rb->rest = cscf->large_client_header_buffers.size;
  1572.     }

  1574.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1576.     max = r->headers_in.content_length_n;

  1578.     if (max == -1 && clcf->client_max_body_size) {
  1579.         max = clcf->client_max_body_size;
  1580.     }

  1582.     out = NULL;
  1583.     ll = &out;
  1584.     last = 0;

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

  1588.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1589.                        "http3 body buf "
  1590.                        "t:%d f:%d %p, pos %p, size: %z file: %O, size: %O",
  1591.                        cl->buf->temporary, cl->buf->in_file,
  1592.                        cl->buf->start, cl->buf->pos,
  1593.                        cl->buf->last - cl->buf->pos,
  1594.                        cl->buf->file_pos,
  1595.                        cl->buf->file_last - cl->buf->file_pos);

  1597.         if (cl->buf->last_buf) {
  1598.             last = 1;
  1599.         }

  1601.         b = NULL;

  1603.         while (cl->buf->pos < cl->buf->last) {

  1605.             if (st->length == 0) {
  1606.                 p = cl->buf->pos;

  1608.                 rc = ngx_http_v3_parse_data(r->connection, st, cl->buf);

  1610.                 r->request_length += cl->buf->pos - p;
  1611.                 h3c->total_bytes += cl->buf->pos - p;

  1613.                 if (ngx_http_v3_check_flood(r->connection) != NGX_OK) {
  1614.                     return NGX_HTTP_CLOSE;
  1615.                 }

  1617.                 if (rc == NGX_AGAIN) {
  1618.                     continue;
  1619.                 }

  1621.                 if (rc == NGX_DONE) {
  1622.                     last = 1;
  1623.                     goto done;
  1624.                 }

  1626.                 if (rc > 0) {
  1627.                     ngx_quic_reset_stream(r->connection, rc);
  1628.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1629.                                   "client sent invalid body");
  1630.                     return NGX_HTTP_BAD_REQUEST;
  1631.                 }

  1633.                 if (rc == NGX_ERROR) {
  1634.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1635.                 }

  1637.                 /* rc == NGX_OK */

  1639.                 if (max != -1 && (uint64_t) (max - rb->received) < st->length) {

  1641.                     if (r->headers_in.content_length_n != -1) {
  1642.                         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1643.                                       "client intended to send body data "
  1644.                                       "larger than declared");

  1646.                         return NGX_HTTP_BAD_REQUEST;
  1647.                     }

  1649.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1650.                                   "client intended to send too large "
  1651.                                   "body: %O+%ui bytes",
  1652.                                   rb->received, st->length);

  1654.                     return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  1655.                 }

  1657.                 continue;
  1658.             }

  1660.             if (b
  1661.                 && st->length <= 128
  1662.                 && (uint64_t) (cl->buf->last - cl->buf->pos) >= st->length)
  1663.             {
  1664.                 rb->received += st->length;
  1665.                 r->request_length += st->length;
  1666.                 h3c->total_bytes += st->length;
  1667.                 h3c->payload_bytes += st->length;

  1669.                 if (st->length < 8) {

  1671.                     while (st->length) {
  1672.                         *b->last++ = *cl->buf->pos++;
  1673.                         st->length--;
  1674.                     }

  1676.                 } else {
  1677.                     ngx_memmove(b->last, cl->buf->pos, st->length);
  1678.                     b->last += st->length;
  1679.                     cl->buf->pos += st->length;
  1680.                     st->length = 0;
  1681.                 }

  1683.                 continue;
  1684.             }

  1686.             tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1687.             if (tl == NULL) {
  1688.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1689.             }

  1691.             b = tl->buf;

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

  1695.             b->temporary = 1;
  1696.             b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
  1697.             b->start = cl->buf->pos;
  1698.             b->pos = cl->buf->pos;
  1699.             b->last = cl->buf->last;
  1700.             b->end = cl->buf->end;
  1701.             b->flush = r->request_body_no_buffering;

  1703.             *ll = tl;
  1704.             ll = &tl->next;

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

  1708.             if (size > st->length) {
  1709.                 cl->buf->pos += (size_t) st->length;
  1710.                 rb->received += st->length;
  1711.                 r->request_length += st->length;
  1712.                 h3c->total_bytes += st->length;
  1713.                 h3c->payload_bytes += st->length;
  1714.                 st->length = 0;

  1716.             } else {
  1717.                 st->length -= size;
  1718.                 rb->received += size;
  1719.                 r->request_length += size;
  1720.                 h3c->total_bytes += size;
  1721.                 h3c->payload_bytes += size;
  1722.                 cl->buf->pos = cl->buf->last;
  1723.             }

  1725.             b->last = cl->buf->pos;
  1726.         }
  1727.     }

  1729. done:

  1731.     if (last) {

  1733.         if (st->length > 0) {
  1734.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1735.                           "client prematurely closed stream");
  1736.             r->connection->error = 1;
  1737.             return NGX_HTTP_BAD_REQUEST;
  1738.         }

  1740.         if (r->headers_in.content_length_n == -1) {
  1741.             r->headers_in.content_length_n = rb->received;

  1743.         } else if (r->headers_in.content_length_n != rb->received) {
  1744.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1745.                           "client sent less body data than expected: "
  1746.                           "%O out of %O bytes of request body received",
  1747.                           rb->received, r->headers_in.content_length_n);
  1748.             return NGX_HTTP_BAD_REQUEST;
  1749.         }

  1751.         rb->rest = 0;

  1753.         tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1754.         if (tl == NULL) {
  1755.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1756.         }

  1758.         b = tl->buf;

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

  1762.         b->last_buf = 1;

  1764.         *ll = tl;

  1766.     } else {

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

  1770.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1772.         rb->rest = (off_t) cscf->large_client_header_buffers.size;
  1773.     }

  1775.     rc = ngx_http_top_request_body_filter(r, out);

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

  1780.     return rc;
  1781. }

One Level Up Top Level