One Level Up Top Level

src/http/v3/ngx_http_v3_request.c - nginx source code

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.         h = ngx_list_push(&r->headers_in.headers);
  669.         if (h == NULL) {
  670.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  671.             return NGX_ERROR;
  672.         }

  674.         h->key = *name;
  675.         h->value = *value;
  676.         h->lowcase_key = h->key.data;
  677.         h->hash = ngx_hash_key(h->key.data, h->key.len);

  679.         cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  684.         if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  685.             return NGX_ERROR;
  686.         }
  687.     }

  689.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  690.                    "http3 header: \"%V: %V\"", name, value);
  691.     return NGX_OK;
  692. }


  695. static ngx_int_t
  696. ‌ngx_http_v3_validate_header(ngx_http_request_t *r, ngx_str_t *name,
  697.     ngx_str_t *value)
  698. {
  699.     u_char                     ch;
  700.     ngx_uint_t                 i;
  701.     ngx_http_core_srv_conf_t  *cscf;

  703.     r->invalid_header = 0;

  705.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

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

  710.         if ((ch >= 'a' && ch <= 'z')
  711.             || (ch == '-')
  712.             || (ch >= '0' && ch <= '9')
  713.             || (ch == '_' && cscf->underscores_in_headers))
  714.         {
  715.             continue;
  716.         }

  718.         if (ch <= 0x20 || ch == 0x7f || ch == ':'
  719.             || (ch >= 'A' && ch <= 'Z'))
  720.         {
  721.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  722.                           "client sent invalid header name: \"%V\"", name);

  724.             return NGX_ERROR;
  725.         }

  727.         r->invalid_header = 1;
  728.     }

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

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

  738.             return NGX_ERROR;
  739.         }
  740.     }

  742.     return NGX_OK;
  743. }


  746. static ngx_int_t
  747. ‌ngx_http_v3_process_pseudo_header(ngx_http_request_t *r, ngx_str_t *name,
  748.     ngx_str_t *value)
  749. {
  750.     u_char      ch, c;
  751.     ngx_uint_t  i;

  753.     if (r->request_line.len) {
  754.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  755.                       "client sent out of order pseudo-headers");
  756.         goto failed;
  757.     }

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

  761.         if (r->method_name.len) {
  762.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  763.                           "client sent duplicate \":method\" header");
  764.             goto failed;
  765.         }

  767.         if (value->len == 0) {
  768.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  769.                           "client sent empty \":method\" header");
  770.             goto failed;
  771.         }

  773.         r->method_name = *value;

  775.         for (i = 0; i < sizeof(ngx_http_v3_methods)
  776.                         / sizeof(ngx_http_v3_methods[0]); i++)
  777.         {
  778.             if (value->len == ngx_http_v3_methods[i].name.len
  779.                 && ngx_strncmp(value->data,
  780.                                ngx_http_v3_methods[i].name.data, value->len)
  781.                    == 0)
  782.             {
  783.                 r->method = ngx_http_v3_methods[i].method;
  784.                 break;
  785.             }
  786.         }

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

  791.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  792.                 ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  793.                               "client sent invalid method: \"%V\"", value);
  794.                 goto failed;
  795.             }
  796.         }

  798.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  799.                        "http3 method \"%V\" %ui", value, r->method);
  800.         return NGX_OK;
  801.     }

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

  805.         if (r->uri_start) {
  806.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  807.                           "client sent duplicate \":path\" header");
  808.             goto failed;
  809.         }

  811.         if (value->len == 0) {
  812.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  813.                           "client sent empty \":path\" header");
  814.             goto failed;
  815.         }

  817.         r->uri_start = value->data;
  818.         r->uri_end = value->data + value->len;

  820.         if (ngx_http_parse_uri(r) != NGX_OK) {
  821.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  822.                           "client sent invalid \":path\" header: \"%V\"",
  823.                           value);
  824.             goto failed;
  825.         }

  827.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  828.                        "http3 path \"%V\"", value);
  829.         return NGX_OK;
  830.     }

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

  834.         if (r->schema.len) {
  835.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  836.                           "client sent duplicate \":scheme\" header");
  837.             goto failed;
  838.         }

  840.         if (value->len == 0) {
  841.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  842.                           "client sent empty \":scheme\" header");
  843.             goto failed;
  844.         }

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

  849.             c = (u_char) (ch | 0x20);
  850.             if (c >= 'a' && c <= 'z') {
  851.                 continue;
  852.             }

  854.             if (((ch >= '0' && ch <= '9')
  855.                  || ch == '+' || ch == '-' || ch == '.')
  856.                 && i > 0)
  857.             {
  858.                 continue;
  859.             }

  861.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  862.                           "client sent invalid \":scheme\" header: \"%V\"",
  863.                           value);
  864.             goto failed;
  865.         }

  867.         r->schema = *value;

  869.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  870.                        "http3 schema \"%V\"", value);
  871.         return NGX_OK;
  872.     }

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

  876.         if (r->host_start) {
  877.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  878.                           "client sent duplicate \":authority\" header");
  879.             goto failed;
  880.         }

  882.         r->host_start = value->data;
  883.         r->host_end = value->data + value->len;

  885.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  886.                        "http3 authority \"%V\"", value);
  887.         return NGX_OK;
  888.     }

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

  893. failed:

  895.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  896.     return NGX_ERROR;
  897. }


  900. static ngx_int_t
  901. ‌ngx_http_v3_init_pseudo_headers(ngx_http_request_t *r)
  902. {
  903.     size_t      len;
  904.     u_char     *p;
  905.     ngx_int_t   rc;
  906.     ngx_str_t   host;

  908.     if (r->request_line.len) {
  909.         return NGX_OK;
  910.     }

  912.     if (r->method_name.len == 0) {
  913.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  914.                       "client sent no \":method\" header");
  915.         goto failed;
  916.     }

  918.     if (r->schema.len == 0) {
  919.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  920.                       "client sent no \":scheme\" header");
  921.         goto failed;
  922.     }

  924.     if (r->uri_start == NULL) {
  925.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  926.                       "client sent no \":path\" header");
  927.         goto failed;
  928.     }

  930.     len = r->method_name.len + 1
  931.           + (r->uri_end - r->uri_start) + 1
  932.           + sizeof("HTTP/3.0") - 1;

  934.     p = ngx_pnalloc(r->pool, len);
  935.     if (p == NULL) {
  936.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  937.         return NGX_ERROR;
  938.     }

  940.     r->request_line.data = p;

  942.     p = ngx_cpymem(p, r->method_name.data, r->method_name.len);
  943.     *p++ = ' ';
  944.     p = ngx_cpymem(p, r->uri_start, r->uri_end - r->uri_start);
  945.     *p++ = ' ';
  946.     p = ngx_cpymem(p, "HTTP/3.0", sizeof("HTTP/3.0") - 1);

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

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

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

  955.     if (ngx_http_process_request_uri(r) != NGX_OK) {
  956.         return NGX_ERROR;
  957.     }

  959.     if (r->host_end) {

  961.         host.len = r->host_end - r->host_start;
  962.         host.data = r->host_start;

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

  966.         if (rc == NGX_DECLINED) {
  967.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  968.                           "client sent invalid host in request line");
  969.             goto failed;
  970.         }

  972.         if (rc == NGX_ERROR) {
  973.             ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  974.             return NGX_ERROR;
  975.         }

  977.         if (ngx_http_set_virtual_server(r, &host) == NGX_ERROR) {
  978.             return NGX_ERROR;
  979.         }

  981.         r->headers_in.server = host;
  982.     }

  984.     if (ngx_list_init(&r->headers_in.headers, r->pool, 20,
  985.                       sizeof(ngx_table_elt_t))
  986.         != NGX_OK)
  987.     {
  988.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  989.         return NGX_ERROR;
  990.     }

  992.     return NGX_OK;

  994. failed:

  996.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  997.     return NGX_ERROR;
  998. }


  1001. static ngx_int_t
  1002. ‌ngx_http_v3_process_request_header(ngx_http_request_t *r)
  1003. {
  1004.     ssize_t                  n;
  1005.     ngx_buf_t               *b;
  1006.     ngx_connection_t        *c;
  1007.     ngx_http_v3_session_t   *h3c;
  1008.     ngx_http_v3_srv_conf_t  *h3scf;

  1010.     c = r->connection;

  1012.     if (ngx_http_v3_init_pseudo_headers(r) != NGX_OK) {
  1013.         return NGX_ERROR;
  1014.     }

  1016.     h3c = ngx_http_v3_get_session(c);
  1017.     h3scf = ngx_http_get_module_srv_conf(r, ngx_http_v3_module);

  1019.     if ((h3c->hq && !h3scf->enable_hq) || (!h3c->hq && !h3scf->enable)) {
  1020.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1021.                       "client attempted to request the server name "
  1022.                       "for which the negotiated protocol is disabled");
  1023.         ngx_http_finalize_request(r, NGX_HTTP_MISDIRECTED_REQUEST);
  1024.         return NGX_ERROR;
  1025.     }

  1027.     if (ngx_http_v3_construct_cookie_header(r) != NGX_OK) {
  1028.         return NGX_ERROR;
  1029.     }

  1031.     if (r->headers_in.server.len == 0) {
  1032.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1033.                       "client sent neither \":authority\" nor \"Host\" header");
  1034.         goto failed;
  1035.     }

  1037.     if (r->headers_in.host) {
  1038.         if (r->headers_in.host->value.len != r->headers_in.server.len
  1039.             || ngx_memcmp(r->headers_in.host->value.data,
  1040.                           r->headers_in.server.data,
  1041.                           r->headers_in.server.len)
  1042.                != 0)
  1043.         {
  1044.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1045.                           "client sent \":authority\" and \"Host\" headers "
  1046.                           "with different values");
  1047.             goto failed;
  1048.         }
  1049.     }

  1051.     if (r->headers_in.content_length) {
  1052.         r->headers_in.content_length_n =
  1053.                             ngx_atoof(r->headers_in.content_length->value.data,
  1054.                                       r->headers_in.content_length->value.len);

  1056.         if (r->headers_in.content_length_n == NGX_ERROR) {
  1057.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  1058.                           "client sent invalid \"Content-Length\" header");
  1059.             goto failed;
  1060.         }

  1062.     } else {
  1063.         b = r->header_in;
  1064.         n = b->last - b->pos;

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

  1069.             if (n == NGX_ERROR) {
  1070.                 ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1071.                 return NGX_ERROR;
  1072.             }

  1074.             if (n > 0) {
  1075.                 b->pos = b->start;
  1076.                 b->last = b->start + n;
  1077.             }
  1078.         }

  1080.         if (n != 0) {
  1081.             r->headers_in.chunked = 1;
  1082.         }
  1083.     }

  1085.     if (r->method == NGX_HTTP_CONNECT) {
  1086.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent CONNECT method");
  1087.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  1088.         return NGX_ERROR;
  1089.     }

  1091.     if (r->method == NGX_HTTP_TRACE) {
  1092.         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent TRACE method");
  1093.         ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
  1094.         return NGX_ERROR;
  1095.     }

  1097.     return NGX_OK;

  1099. failed:

  1101.     ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
  1102.     return NGX_ERROR;
  1103. }


  1106. static ngx_int_t
  1107. ‌ngx_http_v3_cookie(ngx_http_request_t *r, ngx_str_t *value)
  1108. {
  1109.     ngx_str_t    *val;
  1110.     ngx_array_t  *cookies;

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

  1114.     if (cookies == NULL) {
  1115.         cookies = ngx_array_create(r->pool, 2, sizeof(ngx_str_t));
  1116.         if (cookies == NULL) {
  1117.             return NGX_ERROR;
  1118.         }

  1120.         r->v3_parse->cookies = cookies;
  1121.     }

  1123.     val = ngx_array_push(cookies);
  1124.     if (val == NULL) {
  1125.         return NGX_ERROR;
  1126.     }

  1128.     *val = *value;

  1130.     return NGX_OK;
  1131. }


  1134. static ngx_int_t
  1135. ‌ngx_http_v3_construct_cookie_header(ngx_http_request_t *r)
  1136. {
  1137.     u_char                     *buf, *p, *end;
  1138.     size_t                      len;
  1139.     ngx_str_t                  *vals;
  1140.     ngx_uint_t                  i;
  1141.     ngx_array_t                *cookies;
  1142.     ngx_table_elt_t            *h;
  1143.     ngx_http_header_t          *hh;
  1144.     ngx_http_core_main_conf_t  *cmcf;

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

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

  1150.     if (cookies == NULL) {
  1151.         return NGX_OK;
  1152.     }

  1154.     vals = cookies->elts;

  1156.     i = 0;
  1157.     len = 0;

  1159.     do {
  1160.         len += vals[i].len + 2;
  1161.     } while (++i != cookies->nelts);

  1163.     len -= 2;

  1165.     buf = ngx_pnalloc(r->pool, len + 1);
  1166.     if (buf == NULL) {
  1167.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1168.         return NGX_ERROR;
  1169.     }

  1171.     p = buf;
  1172.     end = buf + len;

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

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

  1178.         if (p == end) {
  1179.             *p = '\0';
  1180.             break;
  1181.         }

  1183.         *p++ = ';'; *p++ = ' ';
  1184.     }

  1186.     h = ngx_list_push(&r->headers_in.headers);
  1187.     if (h == NULL) {
  1188.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1189.         return NGX_ERROR;
  1190.     }

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

  1195.     h->key.len = cookie.len;
  1196.     h->key.data = cookie.data;

  1198.     h->value.len = len;
  1199.     h->value.data = buf;

  1201.     h->lowcase_key = cookie.data;

  1203.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

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

  1208.     if (hh == NULL) {
  1209.         ngx_http_close_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  1210.         return NGX_ERROR;
  1211.     }

  1213.     if (hh->handler(r, h, hh->offset) != NGX_OK) {
  1214.         /*
  1215.          * request has been finalized already
  1216.          * in ngx_http_process_multi_header_lines()
  1217.          */
  1218.         return NGX_ERROR;
  1219.     }

  1221.     return NGX_OK;
  1222. }


  1225. ngx_int_t
  1226. ‌ngx_http_v3_read_request_body(ngx_http_request_t *r)
  1227. {
  1228.     size_t                     preread;
  1229.     ngx_int_t                  rc;
  1230.     ngx_chain_t               *cl, out;
  1231.     ngx_http_request_body_t   *rb;
  1232.     ngx_http_core_loc_conf_t  *clcf;

  1234.     rb = r->request_body;

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

  1238.     if (preread) {

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

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

  1245.         out.buf = r->header_in;
  1246.         out.next = NULL;
  1247.         cl = &out;

  1249.     } else {
  1250.         cl = NULL;
  1251.     }

  1253.     rc = ngx_http_v3_request_body_filter(r, cl);
  1254.     if (rc != NGX_OK) {
  1255.         return rc;
  1256.     }

  1258.     if (rb->rest == 0 && rb->last_saved) {
  1259.         /* the whole request body was pre-read */
  1260.         r->request_body_no_buffering = 0;
  1261.         rb->post_handler(r);
  1262.         return NGX_OK;
  1263.     }

  1265.     if (rb->rest < 0) {
  1266.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1267.                       "negative request body rest");
  1268.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1269.     }

  1271.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1273.     rb->buf = ngx_create_temp_buf(r->pool, clcf->client_body_buffer_size);
  1274.     if (rb->buf == NULL) {
  1275.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1276.     }

  1278.     r->read_event_handler = ngx_http_v3_read_client_request_body_handler;
  1279.     r->write_event_handler = ngx_http_request_empty_handler;

  1281.     return ngx_http_v3_do_read_client_request_body(r);
  1282. }


  1285. static void
  1286. ‌ngx_http_v3_read_client_request_body_handler(ngx_http_request_t *r)
  1287. {
  1288.     ngx_int_t  rc;

  1290.     if (r->connection->read->timedout) {
  1291.         r->connection->timedout = 1;
  1292.         ngx_http_finalize_request(r, NGX_HTTP_REQUEST_TIME_OUT);
  1293.         return;
  1294.     }

  1296.     rc = ngx_http_v3_do_read_client_request_body(r);

  1298.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  1299.         ngx_http_finalize_request(r, rc);
  1300.     }
  1301. }


  1304. ngx_int_t
  1305. ‌ngx_http_v3_read_unbuffered_request_body(ngx_http_request_t *r)
  1306. {
  1307.     ngx_int_t  rc;

  1309.     if (r->connection->read->timedout) {
  1310.         r->connection->timedout = 1;
  1311.         return NGX_HTTP_REQUEST_TIME_OUT;
  1312.     }

  1314.     rc = ngx_http_v3_do_read_client_request_body(r);

  1316.     if (rc == NGX_OK) {
  1317.         r->reading_body = 0;
  1318.     }

  1320.     return rc;
  1321. }


  1324. static ngx_int_t
  1325. ‌ngx_http_v3_do_read_client_request_body(ngx_http_request_t *r)
  1326. {
  1327.     off_t                      rest;
  1328.     size_t                     size;
  1329.     ssize_t                    n;
  1330.     ngx_int_t                  rc;
  1331.     ngx_uint_t                 flush;
  1332.     ngx_chain_t                out;
  1333.     ngx_connection_t          *c;
  1334.     ngx_http_request_body_t   *rb;
  1335.     ngx_http_core_loc_conf_t  *clcf;

  1337.     c = r->connection;
  1338.     rb = r->request_body;
  1339.     flush = 1;

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

  1344.     for ( ;; ) {
  1345.         for ( ;; ) {
  1346.             if (rb->rest == 0) {
  1347.                 break;
  1348.             }

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

  1352.                 /* update chains */

  1354.                 rc = ngx_http_v3_request_body_filter(r, NULL);

  1356.                 if (rc != NGX_OK) {
  1357.                     return rc;
  1358.                 }

  1360.                 if (rb->busy != NULL) {
  1361.                     if (r->request_body_no_buffering) {
  1362.                         if (c->read->timer_set) {
  1363.                             ngx_del_timer(c->read);
  1364.                         }

  1366.                         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1367.                             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1368.                         }

  1370.                         return NGX_AGAIN;
  1371.                     }

  1373.                     if (rb->filter_need_buffering) {
  1374.                         clcf = ngx_http_get_module_loc_conf(r,
  1375.                                                          ngx_http_core_module);
  1376.                         ngx_add_timer(c->read, clcf->client_body_timeout);

  1378.                         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1379.                             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1380.                         }

  1382.                         return NGX_AGAIN;
  1383.                     }

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

  1388.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1389.                 }

  1391.                 flush = 0;
  1392.                 rb->buf->pos = rb->buf->start;
  1393.                 rb->buf->last = rb->buf->start;
  1394.             }

  1396.             size = rb->buf->end - rb->buf->last;
  1397.             rest = rb->rest - (rb->buf->last - rb->buf->pos);

  1399.             if ((off_t) size > rest) {
  1400.                 size = (size_t) rest;
  1401.             }

  1403.             if (size == 0) {
  1404.                 break;
  1405.             }

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

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

  1412.             if (n == NGX_AGAIN) {
  1413.                 break;
  1414.             }

  1416.             if (n == 0) {
  1417.                 rb->buf->last_buf = 1;
  1418.             }

  1420.             if (n == NGX_ERROR) {
  1421.                 c->error = 1;
  1422.                 return NGX_HTTP_BAD_REQUEST;
  1423.             }

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

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

  1429.             flush = 0;
  1430.             out.buf = rb->buf;
  1431.             out.next = NULL;

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

  1435.             if (rc != NGX_OK) {
  1436.                 return rc;
  1437.             }

  1439.             if (rb->rest == 0) {
  1440.                 break;
  1441.             }

  1443.             if (rb->buf->last < rb->buf->end) {
  1444.                 break;
  1445.             }
  1446.         }

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

  1451.         if (flush) {
  1452.             rc = ngx_http_v3_request_body_filter(r, NULL);

  1454.             if (rc != NGX_OK) {
  1455.                 return rc;
  1456.             }
  1457.         }

  1459.         if (rb->rest == 0 && rb->last_saved) {
  1460.             break;
  1461.         }

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

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

  1468.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1469.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1470.             }

  1472.             return NGX_AGAIN;
  1473.         }
  1474.     }

  1476.     if (c->read->timer_set) {
  1477.         ngx_del_timer(c->read);
  1478.     }

  1480.     if (!r->request_body_no_buffering) {
  1481.         r->read_event_handler = ngx_http_block_reading;
  1482.         rb->post_handler(r);
  1483.     }

  1485.     return NGX_OK;
  1486. }


  1489. static ngx_int_t
  1490. ‌ngx_http_v3_request_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  1491. {
  1492.     off_t                      max;
  1493.     size_t                     size;
  1494.     u_char                    *p;
  1495.     ngx_int_t                  rc;
  1496.     ngx_buf_t                 *b;
  1497.     ngx_uint_t                 last;
  1498.     ngx_chain_t               *cl, *out, *tl, **ll;
  1499.     ngx_http_v3_session_t     *h3c;
  1500.     ngx_http_request_body_t   *rb;
  1501.     ngx_http_core_loc_conf_t  *clcf;
  1502.     ngx_http_core_srv_conf_t  *cscf;
  1503.     ngx_http_v3_parse_data_t  *st;

  1505.     rb = r->request_body;
  1506.     st = &r->v3_parse->body;

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

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

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

  1515.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1517.         rb->rest = cscf->large_client_header_buffers.size;
  1518.     }

  1520.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1522.     max = r->headers_in.content_length_n;

  1524.     if (max == -1 && clcf->client_max_body_size) {
  1525.         max = clcf->client_max_body_size;
  1526.     }

  1528.     out = NULL;
  1529.     ll = &out;
  1530.     last = 0;

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

  1534.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1535.                        "http3 body buf "
  1536.                        "t:%d f:%d %p, pos %p, size: %z file: %O, size: %O",
  1537.                        cl->buf->temporary, cl->buf->in_file,
  1538.                        cl->buf->start, cl->buf->pos,
  1539.                        cl->buf->last - cl->buf->pos,
  1540.                        cl->buf->file_pos,
  1541.                        cl->buf->file_last - cl->buf->file_pos);

  1543.         if (cl->buf->last_buf) {
  1544.             last = 1;
  1545.         }

  1547.         b = NULL;

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

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

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

  1556.                 r->request_length += cl->buf->pos - p;
  1557.                 h3c->total_bytes += cl->buf->pos - p;

  1559.                 if (ngx_http_v3_check_flood(r->connection) != NGX_OK) {
  1560.                     return NGX_HTTP_CLOSE;
  1561.                 }

  1563.                 if (rc == NGX_AGAIN) {
  1564.                     continue;
  1565.                 }

  1567.                 if (rc == NGX_DONE) {
  1568.                     last = 1;
  1569.                     goto done;
  1570.                 }

  1572.                 if (rc > 0) {
  1573.                     ngx_quic_reset_stream(r->connection, rc);
  1574.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1575.                                   "client sent invalid body");
  1576.                     return NGX_HTTP_BAD_REQUEST;
  1577.                 }

  1579.                 if (rc == NGX_ERROR) {
  1580.                     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1581.                 }

  1583.                 /* rc == NGX_OK */

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

  1587.                     if (r->headers_in.content_length_n != -1) {
  1588.                         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1589.                                       "client intended to send body data "
  1590.                                       "larger than declared");

  1592.                         return NGX_HTTP_BAD_REQUEST;
  1593.                     }

  1595.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1596.                                   "client intended to send too large "
  1597.                                   "body: %O+%ui bytes",
  1598.                                   rb->received, st->length);

  1600.                     return NGX_HTTP_REQUEST_ENTITY_TOO_LARGE;
  1601.                 }

  1603.                 continue;
  1604.             }

  1606.             if (b
  1607.                 && st->length <= 128
  1608.                 && (uint64_t) (cl->buf->last - cl->buf->pos) >= st->length)
  1609.             {
  1610.                 rb->received += st->length;
  1611.                 r->request_length += st->length;
  1612.                 h3c->total_bytes += st->length;
  1613.                 h3c->payload_bytes += st->length;

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

  1617.                     while (st->length) {
  1618.                         *b->last++ = *cl->buf->pos++;
  1619.                         st->length--;
  1620.                     }

  1622.                 } else {
  1623.                     ngx_memmove(b->last, cl->buf->pos, st->length);
  1624.                     b->last += st->length;
  1625.                     cl->buf->pos += st->length;
  1626.                     st->length = 0;
  1627.                 }

  1629.                 continue;
  1630.             }

  1632.             tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1633.             if (tl == NULL) {
  1634.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1635.             }

  1637.             b = tl->buf;

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

  1641.             b->temporary = 1;
  1642.             b->tag = (ngx_buf_tag_t) &ngx_http_read_client_request_body;
  1643.             b->start = cl->buf->pos;
  1644.             b->pos = cl->buf->pos;
  1645.             b->last = cl->buf->last;
  1646.             b->end = cl->buf->end;
  1647.             b->flush = r->request_body_no_buffering;

  1649.             *ll = tl;
  1650.             ll = &tl->next;

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

  1654.             if (size > st->length) {
  1655.                 cl->buf->pos += (size_t) st->length;
  1656.                 rb->received += st->length;
  1657.                 r->request_length += st->length;
  1658.                 h3c->total_bytes += st->length;
  1659.                 h3c->payload_bytes += st->length;
  1660.                 st->length = 0;

  1662.             } else {
  1663.                 st->length -= size;
  1664.                 rb->received += size;
  1665.                 r->request_length += size;
  1666.                 h3c->total_bytes += size;
  1667.                 h3c->payload_bytes += size;
  1668.                 cl->buf->pos = cl->buf->last;
  1669.             }

  1671.             b->last = cl->buf->pos;
  1672.         }
  1673.     }

  1675. done:

  1677.     if (last) {

  1679.         if (st->length > 0) {
  1680.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1681.                           "client prematurely closed stream");
  1682.             r->connection->error = 1;
  1683.             return NGX_HTTP_BAD_REQUEST;
  1684.         }

  1686.         if (r->headers_in.content_length_n == -1) {
  1687.             r->headers_in.content_length_n = rb->received;

  1689.         } else if (r->headers_in.content_length_n != rb->received) {
  1690.             ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  1691.                           "client sent less body data than expected: "
  1692.                           "%O out of %O bytes of request body received",
  1693.                           rb->received, r->headers_in.content_length_n);
  1694.             return NGX_HTTP_BAD_REQUEST;
  1695.         }

  1697.         rb->rest = 0;

  1699.         tl = ngx_chain_get_free_buf(r->pool, &rb->free);
  1700.         if (tl == NULL) {
  1701.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1702.         }

  1704.         b = tl->buf;

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

  1708.         b->last_buf = 1;

  1710.         *ll = tl;

  1712.     } else {

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

  1716.         cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);

  1718.         rb->rest = (off_t) cscf->large_client_header_buffers.size;
  1719.     }

  1721.     rc = ngx_http_top_request_body_filter(r, out);

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

  1726.     return rc;
  1727. }

One Level Up Top Level