One Level Up Top Level

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

Global variables defined

Data types defined

Functions defined

Macros 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. ‌#define ngx_http_v3_table_entry_size(n, v) ((n)->len + (v)->len + 32)


  16. static ngx_int_t ngx_http_v3_evict(ngx_connection_t *c, size_t target);
  17. static void ngx_http_v3_unblock(void *data);
  18. static ngx_int_t ngx_http_v3_new_entry(ngx_connection_t *c);


  21. ‌typedef struct {
  22.     ngx_queue_t        queue;
  23.     ngx_connection_t  *connection;
  24.     ngx_uint_t        *nblocked;
  25. ‌} ngx_http_v3_block_t;


  28. ‌static ngx_http_v3_field_t  ngx_http_v3_static_table[] = {

  30.     { ngx_string(":authority"),            ngx_string("") },
  31.     { ngx_string(":path"),                 ngx_string("/") },
  32.     { ngx_string("age"),                   ngx_string("0") },
  33.     { ngx_string("content-disposition"),   ngx_string("") },
  34.     { ngx_string("content-length"),        ngx_string("0") },
  35.     { ngx_string("cookie"),                ngx_string("") },
  36.     { ngx_string("date"),                  ngx_string("") },
  37.     { ngx_string("etag"),                  ngx_string("") },
  38.     { ngx_string("if-modified-since"),     ngx_string("") },
  39.     { ngx_string("if-none-match"),         ngx_string("") },
  40.     { ngx_string("last-modified"),         ngx_string("") },
  41.     { ngx_string("link"),                  ngx_string("") },
  42.     { ngx_string("location"),              ngx_string("") },
  43.     { ngx_string("referer"),               ngx_string("") },
  44.     { ngx_string("set-cookie"),            ngx_string("") },
  45.     { ngx_string(":method"),               ngx_string("CONNECT") },
  46.     { ngx_string(":method"),               ngx_string("DELETE") },
  47.     { ngx_string(":method"),               ngx_string("GET") },
  48.     { ngx_string(":method"),               ngx_string("HEAD") },
  49.     { ngx_string(":method"),               ngx_string("OPTIONS") },
  50.     { ngx_string(":method"),               ngx_string("POST") },
  51.     { ngx_string(":method"),               ngx_string("PUT") },
  52.     { ngx_string(":scheme"),               ngx_string("http") },
  53.     { ngx_string(":scheme"),               ngx_string("https") },
  54.     { ngx_string(":status"),               ngx_string("103") },
  55.     { ngx_string(":status"),               ngx_string("200") },
  56.     { ngx_string(":status"),               ngx_string("304") },
  57.     { ngx_string(":status"),               ngx_string("404") },
  58.     { ngx_string(":status"),               ngx_string("503") },
  59.     { ngx_string("accept"),                ngx_string("*/*") },
  60.     { ngx_string("accept"),
  61.           ngx_string("application/dns-message") },
  62.     { ngx_string("accept-encoding"),       ngx_string("gzip, deflate, br") },
  63.     { ngx_string("accept-ranges"),         ngx_string("bytes") },
  64.     { ngx_string("access-control-allow-headers"),
  65.                                            ngx_string("cache-control") },
  66.     { ngx_string("access-control-allow-headers"),
  67.                                            ngx_string("content-type") },
  68.     { ngx_string("access-control-allow-origin"),
  69.                                            ngx_string("*") },
  70.     { ngx_string("cache-control"),         ngx_string("max-age=0") },
  71.     { ngx_string("cache-control"),         ngx_string("max-age=2592000") },
  72.     { ngx_string("cache-control"),         ngx_string("max-age=604800") },
  73.     { ngx_string("cache-control"),         ngx_string("no-cache") },
  74.     { ngx_string("cache-control"),         ngx_string("no-store") },
  75.     { ngx_string("cache-control"),
  76.           ngx_string("public, max-age=31536000") },
  77.     { ngx_string("content-encoding"),      ngx_string("br") },
  78.     { ngx_string("content-encoding"),      ngx_string("gzip") },
  79.     { ngx_string("content-type"),
  80.           ngx_string("application/dns-message") },
  81.     { ngx_string("content-type"),
  82.           ngx_string("application/javascript") },
  83.     { ngx_string("content-type"),          ngx_string("application/json") },
  84.     { ngx_string("content-type"),
  85.           ngx_string("application/x-www-form-urlencoded") },
  86.     { ngx_string("content-type"),          ngx_string("image/gif") },
  87.     { ngx_string("content-type"),          ngx_string("image/jpeg") },
  88.     { ngx_string("content-type"),          ngx_string("image/png") },
  89.     { ngx_string("content-type"),          ngx_string("text/css") },
  90.     { ngx_string("content-type"),
  91.           ngx_string("text/html;charset=utf-8") },
  92.     { ngx_string("content-type"),          ngx_string("text/plain") },
  93.     { ngx_string("content-type"),
  94.           ngx_string("text/plain;charset=utf-8") },
  95.     { ngx_string("range"),                 ngx_string("bytes=0-") },
  96.     { ngx_string("strict-transport-security"),
  97.                                            ngx_string("max-age=31536000") },
  98.     { ngx_string("strict-transport-security"),
  99.           ngx_string("max-age=31536000;includesubdomains") },
  100.     { ngx_string("strict-transport-security"),
  101.           ngx_string("max-age=31536000;includesubdomains;preload") },
  102.     { ngx_string("vary"),                  ngx_string("accept-encoding") },
  103.     { ngx_string("vary"),                  ngx_string("origin") },
  104.     { ngx_string("x-content-type-options"),
  105.                                            ngx_string("nosniff") },
  106.     { ngx_string("x-xss-protection"),      ngx_string("1;mode=block") },
  107.     { ngx_string(":status"),               ngx_string("100") },
  108.     { ngx_string(":status"),               ngx_string("204") },
  109.     { ngx_string(":status"),               ngx_string("206") },
  110.     { ngx_string(":status"),               ngx_string("302") },
  111.     { ngx_string(":status"),               ngx_string("400") },
  112.     { ngx_string(":status"),               ngx_string("403") },
  113.     { ngx_string(":status"),               ngx_string("421") },
  114.     { ngx_string(":status"),               ngx_string("425") },
  115.     { ngx_string(":status"),               ngx_string("500") },
  116.     { ngx_string("accept-language"),       ngx_string("") },
  117.     { ngx_string("access-control-allow-credentials"),
  118.                                            ngx_string("FALSE") },
  119.     { ngx_string("access-control-allow-credentials"),
  120.                                            ngx_string("TRUE") },
  121.     { ngx_string("access-control-allow-headers"),
  122.                                            ngx_string("*") },
  123.     { ngx_string("access-control-allow-methods"),
  124.                                            ngx_string("get") },
  125.     { ngx_string("access-control-allow-methods"),
  126.                                            ngx_string("get, post, options") },
  127.     { ngx_string("access-control-allow-methods"),
  128.                                            ngx_string("options") },
  129.     { ngx_string("access-control-expose-headers"),
  130.                                            ngx_string("content-length") },
  131.     { ngx_string("access-control-request-headers"),
  132.                                            ngx_string("content-type") },
  133.     { ngx_string("access-control-request-method"),
  134.                                            ngx_string("get") },
  135.     { ngx_string("access-control-request-method"),
  136.                                            ngx_string("post") },
  137.     { ngx_string("alt-svc"),               ngx_string("clear") },
  138.     { ngx_string("authorization"),         ngx_string("") },
  139.     { ngx_string("content-security-policy"),
  140.           ngx_string("script-src 'none';object-src 'none';base-uri 'none'") },
  141.     { ngx_string("early-data"),            ngx_string("1") },
  142.     { ngx_string("expect-ct"),             ngx_string("") },
  143.     { ngx_string("forwarded"),             ngx_string("") },
  144.     { ngx_string("if-range"),              ngx_string("") },
  145.     { ngx_string("origin"),                ngx_string("") },
  146.     { ngx_string("purpose"),               ngx_string("prefetch") },
  147.     { ngx_string("server"),                ngx_string("") },
  148.     { ngx_string("timing-allow-origin"),   ngx_string("*") },
  149.     { ngx_string("upgrade-insecure-requests"),
  150.                                            ngx_string("1") },
  151.     { ngx_string("user-agent"),            ngx_string("") },
  152.     { ngx_string("x-forwarded-for"),       ngx_string("") },
  153.     { ngx_string("x-frame-options"),       ngx_string("deny") },
  154.     { ngx_string("x-frame-options"),       ngx_string("sameorigin") }
  155. };


  158. ngx_buf_t *
  159. ‌ngx_http_v3_get_insert_buffer(ngx_connection_t *c)
  160. {
  161.     ngx_http_v3_session_t        *h3c;
  162.     ngx_http_v3_srv_conf_t       *h3scf;
  163.     ngx_http_v3_dynamic_table_t  *dt;

  165.     h3c = ngx_http_v3_get_session(c);
  166.     dt = &h3c->table;

  168.     if (dt->insert_buffer == NULL) {
  169.         h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  171.         dt->insert_buffer = ngx_create_temp_buf(c->quic->parent->pool,
  172.                                                 h3scf->max_table_capacity);
  173.         if (dt->insert_buffer == NULL) {
  174.             return NULL;
  175.         }
  176.     }

  178.     dt->insert_buffer->last = dt->insert_buffer->pos;

  180.     return dt->insert_buffer;
  181. }


  184. ngx_int_t
  185. ‌ngx_http_v3_ref_insert(ngx_connection_t *c, ngx_uint_t dynamic,
  186.     ngx_uint_t index, ngx_str_t *value)
  187. {
  188.     ngx_str_t                     name;
  189.     ngx_http_v3_session_t        *h3c;
  190.     ngx_http_v3_dynamic_table_t  *dt;

  192.     if (dynamic) {
  193.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  194.                        "http3 ref insert dynamic[%ui] \"%V\"", index, value);

  196.         h3c = ngx_http_v3_get_session(c);
  197.         dt = &h3c->table;

  199.         if (dt->base + dt->nelts <= index) {
  200.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  201.         }

  203.         index = dt->base + dt->nelts - 1 - index;

  205.         if (ngx_http_v3_lookup(c, index, &name, NULL) != NGX_OK) {
  206.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  207.         }

  209.     } else {
  210.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  211.                        "http3 ref insert static[%ui] \"%V\"", index, value);

  213.         if (ngx_http_v3_lookup_static(c, index, &name, NULL) != NGX_OK) {
  214.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  215.         }
  216.     }

  218.     return ngx_http_v3_insert(c, &name, value);
  219. }


  222. ngx_int_t
  223. ‌ngx_http_v3_insert(ngx_connection_t *c, ngx_str_t *name, ngx_str_t *value)
  224. {
  225.     u_char                       *p;
  226.     size_t                        size;
  227.     ngx_http_v3_field_t          *field;
  228.     ngx_http_v3_session_t        *h3c;
  229.     ngx_http_v3_dynamic_table_t  *dt;

  231.     size = ngx_http_v3_table_entry_size(name, value);

  233.     h3c = ngx_http_v3_get_session(c);
  234.     dt = &h3c->table;

  236.     if (size > dt->capacity) {
  237.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  238.                       "not enough dynamic table capacity");
  239.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  240.     }

  242.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, c->log, 0,
  243.                    "http3 insert [%ui] \"%V\":\"%V\", size:%uz",
  244.                    dt->base + dt->nelts, name, value, size);

  246.     p = ngx_alloc(sizeof(ngx_http_v3_field_t) + name->len + value->len,
  247.                   c->log);
  248.     if (p == NULL) {
  249.         return NGX_ERROR;
  250.     }

  252.     field = (ngx_http_v3_field_t *) p;

  254.     field->name.data = p + sizeof(ngx_http_v3_field_t);
  255.     field->name.len = name->len;
  256.     field->value.data = ngx_cpymem(field->name.data, name->data, name->len);
  257.     field->value.len = value->len;
  258.     ngx_memcpy(field->value.data, value->data, value->len);

  260.     dt->elts[dt->nelts++] = field;
  261.     dt->size += size;

  263.     dt->insert_count++;

  265.     if (ngx_http_v3_evict(c, dt->capacity) != NGX_OK) {
  266.         return NGX_ERROR;
  267.     }

  269.     ngx_post_event(&dt->send_insert_count, &ngx_posted_events);

  271.     if (ngx_http_v3_new_entry(c) != NGX_OK) {
  272.         return NGX_ERROR;
  273.     }

  275.     return NGX_OK;
  276. }


  279. void
  280. ‌ngx_http_v3_inc_insert_count_handler(ngx_event_t *ev)
  281. {
  282.     ngx_connection_t             *c;
  283.     ngx_http_v3_session_t        *h3c;
  284.     ngx_http_v3_dynamic_table_t  *dt;

  286.     c = ev->data;

  288.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  289.                    "http3 inc insert count handler");

  291.     h3c = ngx_http_v3_get_session(c);
  292.     dt = &h3c->table;

  294.     if (dt->insert_count > dt->ack_insert_count) {
  295.         if (ngx_http_v3_send_inc_insert_count(c,
  296.                                        dt->insert_count - dt->ack_insert_count)
  297.             != NGX_OK)
  298.         {
  299.             return;
  300.         }

  302.         dt->ack_insert_count = dt->insert_count;
  303.     }
  304. }


  307. ngx_int_t
  308. ‌ngx_http_v3_set_capacity(ngx_connection_t *c, ngx_uint_t capacity)
  309. {
  310.     ngx_uint_t                     max, prev_max;
  311.     ngx_http_v3_field_t          **elts;
  312.     ngx_http_v3_session_t         *h3c;
  313.     ngx_http_v3_srv_conf_t        *h3scf;
  314.     ngx_http_v3_dynamic_table_t   *dt;

  316.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  317.                    "http3 set capacity %ui", capacity);

  319.     h3c = ngx_http_v3_get_session(c);
  320.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  322.     if (capacity > h3scf->max_table_capacity) {
  323.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  324.                       "client exceeded http3_max_table_capacity limit");
  325.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  326.     }

  328.     if (ngx_http_v3_evict(c, capacity) != NGX_OK) {
  329.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  330.     }

  332.     dt = &h3c->table;
  333.     max = capacity / 32;
  334.     prev_max = dt->capacity / 32;

  336.     if (max > prev_max) {
  337.         elts = ngx_alloc((max + 1) * sizeof(void *), c->log);
  338.         if (elts == NULL) {
  339.             return NGX_ERROR;
  340.         }

  342.         if (dt->elts) {
  343.             ngx_memcpy(elts, dt->elts, dt->nelts * sizeof(void *));
  344.             ngx_free(dt->elts);
  345.         }

  347.         dt->elts = elts;
  348.     }

  350.     dt->capacity = capacity;

  352.     return NGX_OK;
  353. }


  356. void
  357. ‌ngx_http_v3_cleanup_table(ngx_http_v3_session_t *h3c)
  358. {
  359.     ngx_uint_t                    n;
  360.     ngx_http_v3_dynamic_table_t  *dt;

  362.     dt = &h3c->table;

  364.     if (dt->elts == NULL) {
  365.         return;
  366.     }

  368.     for (n = 0; n < dt->nelts; n++) {
  369.         ngx_free(dt->elts[n]);
  370.     }

  372.     ngx_free(dt->elts);
  373. }


  376. static ngx_int_t
  377. ‌ngx_http_v3_evict(ngx_connection_t *c, size_t target)
  378. {
  379.     size_t                        size;
  380.     ngx_uint_t                    n;
  381.     ngx_http_v3_field_t          *field;
  382.     ngx_http_v3_session_t        *h3c;
  383.     ngx_http_v3_dynamic_table_t  *dt;

  385.     h3c = ngx_http_v3_get_session(c);
  386.     dt = &h3c->table;
  387.     n = 0;

  389.     while (dt->size > target) {
  390.         field = dt->elts[n++];
  391.         size = ngx_http_v3_table_entry_size(&field->name, &field->value);

  393.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, c->log, 0,
  394.                        "http3 evict [%ui] \"%V\":\"%V\" size:%uz",
  395.                        dt->base, &field->name, &field->value, size);

  397.         ngx_free(field);
  398.         dt->size -= size;
  399.     }

  401.     if (n) {
  402.         dt->nelts -= n;
  403.         dt->base += n;
  404.         ngx_memmove(dt->elts, &dt->elts[n], dt->nelts * sizeof(void *));
  405.     }

  407.     return NGX_OK;
  408. }


  411. ngx_int_t
  412. ‌ngx_http_v3_duplicate(ngx_connection_t *c, ngx_uint_t index)
  413. {
  414.     ngx_str_t                     name, value;
  415.     ngx_http_v3_session_t        *h3c;
  416.     ngx_http_v3_dynamic_table_t  *dt;

  418.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 duplicate %ui", index);

  420.     h3c = ngx_http_v3_get_session(c);
  421.     dt = &h3c->table;

  423.     if (dt->base + dt->nelts <= index) {
  424.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  425.     }

  427.     index = dt->base + dt->nelts - 1 - index;

  429.     if (ngx_http_v3_lookup(c, index, &name, &value) != NGX_OK) {
  430.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  431.     }

  433.     return ngx_http_v3_insert(c, &name, &value);
  434. }


  437. ngx_int_t
  438. ‌ngx_http_v3_ack_section(ngx_connection_t *c, ngx_uint_t stream_id)
  439. {
  440.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  441.                    "http3 ack section %ui", stream_id);

  443.     /* we do not use dynamic tables */

  445.     return NGX_HTTP_V3_ERR_DECODER_STREAM_ERROR;
  446. }


  449. ngx_int_t
  450. ‌ngx_http_v3_inc_insert_count(ngx_connection_t *c, ngx_uint_t inc)
  451. {
  452.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  453.                    "http3 increment insert count %ui", inc);

  455.     /* we do not use dynamic tables */

  457.     return NGX_HTTP_V3_ERR_DECODER_STREAM_ERROR;
  458. }


  461. ngx_int_t
  462. ‌ngx_http_v3_lookup_static(ngx_connection_t *c, ngx_uint_t index,
  463.     ngx_str_t *name, ngx_str_t *value)
  464. {
  465.     ngx_uint_t            nelts;
  466.     ngx_http_v3_field_t  *field;

  468.     nelts = sizeof(ngx_http_v3_static_table)
  469.             / sizeof(ngx_http_v3_static_table[0]);

  471.     if (index >= nelts) {
  472.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  473.                        "http3 static[%ui] lookup out of bounds: %ui",
  474.                        index, nelts);
  475.         return NGX_ERROR;
  476.     }

  478.     field = &ngx_http_v3_static_table[index];

  480.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  481.                    "http3 static[%ui] lookup \"%V\":\"%V\"",
  482.                    index, &field->name, &field->value);

  484.     if (name) {
  485.         *name = field->name;
  486.     }

  488.     if (value) {
  489.         *value = field->value;
  490.     }

  492.     return NGX_OK;
  493. }


  496. ngx_int_t
  497. ‌ngx_http_v3_lookup(ngx_connection_t *c, ngx_uint_t index, ngx_str_t *name,
  498.     ngx_str_t *value)
  499. {
  500.     ngx_http_v3_field_t          *field;
  501.     ngx_http_v3_session_t        *h3c;
  502.     ngx_http_v3_dynamic_table_t  *dt;

  504.     h3c = ngx_http_v3_get_session(c);
  505.     dt = &h3c->table;

  507.     if (index < dt->base || index - dt->base >= dt->nelts) {
  508.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  509.                        "http3 dynamic[%ui] lookup out of bounds: [%ui,%ui]",
  510.                        index, dt->base, dt->base + dt->nelts);
  511.         return NGX_ERROR;
  512.     }

  514.     field = dt->elts[index - dt->base];

  516.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  517.                    "http3 dynamic[%ui] lookup \"%V\":\"%V\"",
  518.                    index, &field->name, &field->value);

  520.     if (name) {
  521.         *name = field->name;
  522.     }

  524.     if (value) {
  525.         *value = field->value;
  526.     }

  528.     return NGX_OK;
  529. }


  532. ngx_int_t
  533. ‌ngx_http_v3_decode_insert_count(ngx_connection_t *c, ngx_uint_t *insert_count)
  534. {
  535.     ngx_uint_t                    max_entries, full_range, max_value,
  536.                                   max_wrapped, req_insert_count;
  537.     ngx_http_v3_srv_conf_t       *h3scf;
  538.     ngx_http_v3_session_t        *h3c;
  539.     ngx_http_v3_dynamic_table_t  *dt;

  541.     /* QPACK 4.5.1.1. Required Insert Count */

  543.     if (*insert_count == 0) {
  544.         return NGX_OK;
  545.     }

  547.     h3c = ngx_http_v3_get_session(c);
  548.     dt = &h3c->table;

  550.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  552.     max_entries = h3scf->max_table_capacity / 32;
  553.     full_range = 2 * max_entries;

  555.     if (*insert_count > full_range) {
  556.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  557.     }

  559.     max_value = dt->base + dt->nelts + max_entries;
  560.     max_wrapped = (max_value / full_range) * full_range;
  561.     req_insert_count = max_wrapped + *insert_count - 1;

  563.     if (req_insert_count > max_value) {
  564.         if (req_insert_count <= full_range) {
  565.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  566.         }

  568.         req_insert_count -= full_range;
  569.     }

  571.     if (req_insert_count == 0) {
  572.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  573.     }

  575.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  576.                    "http3 decode insert_count %ui -> %ui",
  577.                    *insert_count, req_insert_count);

  579.     *insert_count = req_insert_count;

  581.     return NGX_OK;
  582. }


  585. ngx_int_t
  586. ‌ngx_http_v3_check_insert_count(ngx_connection_t *c, ngx_uint_t insert_count)
  587. {
  588.     size_t                        n;
  589.     ngx_pool_cleanup_t           *cln;
  590.     ngx_http_v3_block_t          *block;
  591.     ngx_http_v3_session_t        *h3c;
  592.     ngx_http_v3_srv_conf_t       *h3scf;
  593.     ngx_http_v3_dynamic_table_t  *dt;

  595.     h3c = ngx_http_v3_get_session(c);
  596.     dt = &h3c->table;

  598.     n = dt->base + dt->nelts;

  600.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  601.                    "http3 check insert count req:%ui, have:%ui",
  602.                    insert_count, n);

  604.     if (n >= insert_count) {
  605.         return NGX_OK;
  606.     }

  608.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 block stream");

  610.     block = NULL;

  612.     for (cln = c->pool->cleanup; cln; cln = cln->next) {
  613.         if (cln->handler == ngx_http_v3_unblock) {
  614.             block = cln->data;
  615.             break;
  616.         }
  617.     }

  619.     if (block == NULL) {
  620.         cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_v3_block_t));
  621.         if (cln == NULL) {
  622.             return NGX_ERROR;
  623.         }

  625.         cln->handler = ngx_http_v3_unblock;

  627.         block = cln->data;
  628.         block->queue.prev = NULL;
  629.         block->connection = c;
  630.         block->nblocked = &h3c->nblocked;
  631.     }

  633.     if (block->queue.prev == NULL) {
  634.         h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  636.         if (h3c->nblocked == h3scf->max_blocked_streams) {
  637.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  638.                           "client exceeded http3_max_blocked_streams limit");

  640.             ngx_http_v3_finalize_connection(c,
  641.                                           NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED,
  642.                                           "too many blocked streams");
  643.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  644.         }

  646.         h3c->nblocked++;
  647.         ngx_queue_insert_tail(&h3c->blocked, &block->queue);
  648.     }

  650.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  651.                    "http3 blocked:%ui", h3c->nblocked);

  653.     return NGX_BUSY;
  654. }


  657. void
  658. ‌ngx_http_v3_ack_insert_count(ngx_connection_t *c, uint64_t insert_count)
  659. {
  660.     ngx_http_v3_session_t        *h3c;
  661.     ngx_http_v3_dynamic_table_t  *dt;

  663.     h3c = ngx_http_v3_get_session(c);
  664.     dt = &h3c->table;

  666.     if (dt->ack_insert_count < insert_count) {
  667.         dt->ack_insert_count = insert_count;
  668.     }
  669. }


  672. static void
  673. ‌ngx_http_v3_unblock(void *data)
  674. {
  675.     ngx_http_v3_block_t  *block = data;

  677.     if (block->queue.prev) {
  678.         ngx_queue_remove(&block->queue);
  679.         block->queue.prev = NULL;
  680.         (*block->nblocked)--;
  681.     }
  682. }


  685. static ngx_int_t
  686. ‌ngx_http_v3_new_entry(ngx_connection_t *c)
  687. {
  688.     ngx_queue_t            *q;
  689.     ngx_connection_t       *bc;
  690.     ngx_http_v3_block_t    *block;
  691.     ngx_http_v3_session_t  *h3c;

  693.     h3c = ngx_http_v3_get_session(c);

  695.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  696.                    "http3 new dynamic entry, blocked:%ui", h3c->nblocked);

  698.     while (!ngx_queue_empty(&h3c->blocked)) {
  699.         q = ngx_queue_head(&h3c->blocked);
  700.         block = (ngx_http_v3_block_t *) q;
  701.         bc = block->connection;

  703.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, bc->log, 0, "http3 unblock stream");

  705.         ngx_http_v3_unblock(block);
  706.         ngx_post_event(bc->read, &ngx_posted_events);
  707.     }

  709.     return NGX_OK;
  710. }


  713. ngx_int_t
  714. ‌ngx_http_v3_set_param(ngx_connection_t *c, uint64_t id, uint64_t value)
  715. {
  716.     switch (id) {

  718.     case NGX_HTTP_V3_PARAM_MAX_TABLE_CAPACITY:
  719.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  720.                        "http3 param QPACK_MAX_TABLE_CAPACITY:%uL", value);
  721.         break;

  723.     case NGX_HTTP_V3_PARAM_MAX_FIELD_SECTION_SIZE:
  724.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  725.                        "http3 param SETTINGS_MAX_FIELD_SECTION_SIZE:%uL",
  726.                        value);
  727.         break;

  729.     case NGX_HTTP_V3_PARAM_BLOCKED_STREAMS:
  730.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  731.                        "http3 param QPACK_BLOCKED_STREAMS:%uL", value);
  732.         break;

  734.     default:

  736.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  737.                        "http3 param #%uL:%uL", id, value);
  738.     }

  740.     return NGX_OK;
  741. }

One Level Up Top Level