One Level Up Top Level

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

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_int_t
  159. ‌ngx_http_v3_ref_insert(ngx_connection_t *c, ngx_uint_t dynamic,
  160.     ngx_uint_t index, ngx_str_t *value)
  161. {
  162.     ngx_str_t                     name;
  163.     ngx_http_v3_session_t        *h3c;
  164.     ngx_http_v3_dynamic_table_t  *dt;

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

  170.         h3c = ngx_http_v3_get_session(c);
  171.         dt = &h3c->table;

  173.         if (dt->base + dt->nelts <= index) {
  174.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  175.         }

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

  179.         if (ngx_http_v3_lookup(c, index, &name, NULL) != NGX_OK) {
  180.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  181.         }

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

  187.         if (ngx_http_v3_lookup_static(c, index, &name, NULL) != NGX_OK) {
  188.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  189.         }
  190.     }

  192.     return ngx_http_v3_insert(c, &name, value);
  193. }


  196. ngx_int_t
  197. ‌ngx_http_v3_insert(ngx_connection_t *c, ngx_str_t *name, ngx_str_t *value)
  198. {
  199.     u_char                       *p;
  200.     size_t                        size;
  201.     ngx_http_v3_field_t          *field;
  202.     ngx_http_v3_session_t        *h3c;
  203.     ngx_http_v3_dynamic_table_t  *dt;

  205.     size = ngx_http_v3_table_entry_size(name, value);

  207.     h3c = ngx_http_v3_get_session(c);
  208.     dt = &h3c->table;

  210.     if (size > dt->capacity) {
  211.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  212.                       "not enough dynamic table capacity");
  213.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  214.     }

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

  220.     p = ngx_alloc(sizeof(ngx_http_v3_field_t) + name->len + value->len,
  221.                   c->log);
  222.     if (p == NULL) {
  223.         return NGX_ERROR;
  224.     }

  226.     field = (ngx_http_v3_field_t *) p;

  228.     field->name.data = p + sizeof(ngx_http_v3_field_t);
  229.     field->name.len = name->len;
  230.     field->value.data = ngx_cpymem(field->name.data, name->data, name->len);
  231.     field->value.len = value->len;
  232.     ngx_memcpy(field->value.data, value->data, value->len);

  234.     dt->elts[dt->nelts++] = field;
  235.     dt->size += size;

  237.     dt->insert_count++;

  239.     if (ngx_http_v3_evict(c, dt->capacity) != NGX_OK) {
  240.         return NGX_ERROR;
  241.     }

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

  245.     if (ngx_http_v3_new_entry(c) != NGX_OK) {
  246.         return NGX_ERROR;
  247.     }

  249.     return NGX_OK;
  250. }


  253. void
  254. ‌ngx_http_v3_inc_insert_count_handler(ngx_event_t *ev)
  255. {
  256.     ngx_connection_t             *c;
  257.     ngx_http_v3_session_t        *h3c;
  258.     ngx_http_v3_dynamic_table_t  *dt;

  260.     c = ev->data;

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

  265.     h3c = ngx_http_v3_get_session(c);
  266.     dt = &h3c->table;

  268.     if (dt->insert_count > dt->ack_insert_count) {
  269.         if (ngx_http_v3_send_inc_insert_count(c,
  270.                                        dt->insert_count - dt->ack_insert_count)
  271.             != NGX_OK)
  272.         {
  273.             return;
  274.         }

  276.         dt->ack_insert_count = dt->insert_count;
  277.     }
  278. }


  281. ngx_int_t
  282. ‌ngx_http_v3_set_capacity(ngx_connection_t *c, ngx_uint_t capacity)
  283. {
  284.     ngx_uint_t                     max, prev_max;
  285.     ngx_http_v3_field_t          **elts;
  286.     ngx_http_v3_session_t         *h3c;
  287.     ngx_http_v3_srv_conf_t        *h3scf;
  288.     ngx_http_v3_dynamic_table_t   *dt;

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

  293.     h3c = ngx_http_v3_get_session(c);
  294.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  296.     if (capacity > h3scf->max_table_capacity) {
  297.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  298.                       "client exceeded http3_max_table_capacity limit");
  299.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  300.     }

  302.     if (ngx_http_v3_evict(c, capacity) != NGX_OK) {
  303.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  304.     }

  306.     dt = &h3c->table;
  307.     max = capacity / 32;
  308.     prev_max = dt->capacity / 32;

  310.     if (max > prev_max) {
  311.         elts = ngx_alloc((max + 1) * sizeof(void *), c->log);
  312.         if (elts == NULL) {
  313.             return NGX_ERROR;
  314.         }

  316.         if (dt->elts) {
  317.             ngx_memcpy(elts, dt->elts, dt->nelts * sizeof(void *));
  318.             ngx_free(dt->elts);
  319.         }

  321.         dt->elts = elts;
  322.     }

  324.     dt->capacity = capacity;

  326.     return NGX_OK;
  327. }


  330. void
  331. ‌ngx_http_v3_cleanup_table(ngx_http_v3_session_t *h3c)
  332. {
  333.     ngx_uint_t                    n;
  334.     ngx_http_v3_dynamic_table_t  *dt;

  336.     dt = &h3c->table;

  338.     if (dt->elts == NULL) {
  339.         return;
  340.     }

  342.     for (n = 0; n < dt->nelts; n++) {
  343.         ngx_free(dt->elts[n]);
  344.     }

  346.     ngx_free(dt->elts);
  347. }


  350. static ngx_int_t
  351. ‌ngx_http_v3_evict(ngx_connection_t *c, size_t target)
  352. {
  353.     size_t                        size;
  354.     ngx_uint_t                    n;
  355.     ngx_http_v3_field_t          *field;
  356.     ngx_http_v3_session_t        *h3c;
  357.     ngx_http_v3_dynamic_table_t  *dt;

  359.     h3c = ngx_http_v3_get_session(c);
  360.     dt = &h3c->table;
  361.     n = 0;

  363.     while (dt->size > target) {
  364.         field = dt->elts[n++];
  365.         size = ngx_http_v3_table_entry_size(&field->name, &field->value);

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

  371.         ngx_free(field);
  372.         dt->size -= size;
  373.     }

  375.     if (n) {
  376.         dt->nelts -= n;
  377.         dt->base += n;
  378.         ngx_memmove(dt->elts, &dt->elts[n], dt->nelts * sizeof(void *));
  379.     }

  381.     return NGX_OK;
  382. }


  385. ngx_int_t
  386. ‌ngx_http_v3_duplicate(ngx_connection_t *c, ngx_uint_t index)
  387. {
  388.     ngx_str_t                     name, value;
  389.     ngx_http_v3_session_t        *h3c;
  390.     ngx_http_v3_dynamic_table_t  *dt;

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

  394.     h3c = ngx_http_v3_get_session(c);
  395.     dt = &h3c->table;

  397.     if (dt->base + dt->nelts <= index) {
  398.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  399.     }

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

  403.     if (ngx_http_v3_lookup(c, index, &name, &value) != NGX_OK) {
  404.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  405.     }

  407.     return ngx_http_v3_insert(c, &name, &value);
  408. }


  411. ngx_int_t
  412. ‌ngx_http_v3_ack_section(ngx_connection_t *c, ngx_uint_t stream_id)
  413. {
  414.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  415.                    "http3 ack section %ui", stream_id);

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

  419.     return NGX_HTTP_V3_ERR_DECODER_STREAM_ERROR;
  420. }


  423. ngx_int_t
  424. ‌ngx_http_v3_inc_insert_count(ngx_connection_t *c, ngx_uint_t inc)
  425. {
  426.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  427.                    "http3 increment insert count %ui", inc);

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

  431.     return NGX_HTTP_V3_ERR_DECODER_STREAM_ERROR;
  432. }


  435. ngx_int_t
  436. ‌ngx_http_v3_lookup_static(ngx_connection_t *c, ngx_uint_t index,
  437.     ngx_str_t *name, ngx_str_t *value)
  438. {
  439.     ngx_uint_t            nelts;
  440.     ngx_http_v3_field_t  *field;

  442.     nelts = sizeof(ngx_http_v3_static_table)
  443.             / sizeof(ngx_http_v3_static_table[0]);

  445.     if (index >= nelts) {
  446.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  447.                        "http3 static[%ui] lookup out of bounds: %ui",
  448.                        index, nelts);
  449.         return NGX_ERROR;
  450.     }

  452.     field = &ngx_http_v3_static_table[index];

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

  458.     if (name) {
  459.         *name = field->name;
  460.     }

  462.     if (value) {
  463.         *value = field->value;
  464.     }

  466.     return NGX_OK;
  467. }


  470. ngx_int_t
  471. ‌ngx_http_v3_lookup(ngx_connection_t *c, ngx_uint_t index, ngx_str_t *name,
  472.     ngx_str_t *value)
  473. {
  474.     ngx_http_v3_field_t          *field;
  475.     ngx_http_v3_session_t        *h3c;
  476.     ngx_http_v3_dynamic_table_t  *dt;

  478.     h3c = ngx_http_v3_get_session(c);
  479.     dt = &h3c->table;

  481.     if (index < dt->base || index - dt->base >= dt->nelts) {
  482.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  483.                        "http3 dynamic[%ui] lookup out of bounds: [%ui,%ui]",
  484.                        index, dt->base, dt->base + dt->nelts);
  485.         return NGX_ERROR;
  486.     }

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

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

  494.     if (name) {
  495.         *name = field->name;
  496.     }

  498.     if (value) {
  499.         *value = field->value;
  500.     }

  502.     return NGX_OK;
  503. }


  506. ngx_int_t
  507. ‌ngx_http_v3_decode_insert_count(ngx_connection_t *c, ngx_uint_t *insert_count)
  508. {
  509.     ngx_uint_t                    max_entries, full_range, max_value,
  510.                                   max_wrapped, req_insert_count;
  511.     ngx_http_v3_srv_conf_t       *h3scf;
  512.     ngx_http_v3_session_t        *h3c;
  513.     ngx_http_v3_dynamic_table_t  *dt;

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

  517.     if (*insert_count == 0) {
  518.         return NGX_OK;
  519.     }

  521.     h3c = ngx_http_v3_get_session(c);
  522.     dt = &h3c->table;

  524.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  526.     max_entries = h3scf->max_table_capacity / 32;
  527.     full_range = 2 * max_entries;

  529.     if (*insert_count > full_range) {
  530.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  531.     }

  533.     max_value = dt->base + dt->nelts + max_entries;
  534.     max_wrapped = (max_value / full_range) * full_range;
  535.     req_insert_count = max_wrapped + *insert_count - 1;

  537.     if (req_insert_count > max_value) {
  538.         if (req_insert_count <= full_range) {
  539.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  540.         }

  542.         req_insert_count -= full_range;
  543.     }

  545.     if (req_insert_count == 0) {
  546.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  547.     }

  549.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  550.                    "http3 decode insert_count %ui -> %ui",
  551.                    *insert_count, req_insert_count);

  553.     *insert_count = req_insert_count;

  555.     return NGX_OK;
  556. }


  559. ngx_int_t
  560. ‌ngx_http_v3_check_insert_count(ngx_connection_t *c, ngx_uint_t insert_count)
  561. {
  562.     size_t                        n;
  563.     ngx_pool_cleanup_t           *cln;
  564.     ngx_http_v3_block_t          *block;
  565.     ngx_http_v3_session_t        *h3c;
  566.     ngx_http_v3_srv_conf_t       *h3scf;
  567.     ngx_http_v3_dynamic_table_t  *dt;

  569.     h3c = ngx_http_v3_get_session(c);
  570.     dt = &h3c->table;

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

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

  578.     if (n >= insert_count) {
  579.         return NGX_OK;
  580.     }

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

  584.     block = NULL;

  586.     for (cln = c->pool->cleanup; cln; cln = cln->next) {
  587.         if (cln->handler == ngx_http_v3_unblock) {
  588.             block = cln->data;
  589.             break;
  590.         }
  591.     }

  593.     if (block == NULL) {
  594.         cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_v3_block_t));
  595.         if (cln == NULL) {
  596.             return NGX_ERROR;
  597.         }

  599.         cln->handler = ngx_http_v3_unblock;

  601.         block = cln->data;
  602.         block->queue.prev = NULL;
  603.         block->connection = c;
  604.         block->nblocked = &h3c->nblocked;
  605.     }

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

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

  614.             ngx_http_v3_finalize_connection(c,
  615.                                           NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED,
  616.                                           "too many blocked streams");
  617.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  618.         }

  620.         h3c->nblocked++;
  621.         ngx_queue_insert_tail(&h3c->blocked, &block->queue);
  622.     }

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

  627.     return NGX_BUSY;
  628. }


  631. void
  632. ‌ngx_http_v3_ack_insert_count(ngx_connection_t *c, uint64_t insert_count)
  633. {
  634.     ngx_http_v3_session_t        *h3c;
  635.     ngx_http_v3_dynamic_table_t  *dt;

  637.     h3c = ngx_http_v3_get_session(c);
  638.     dt = &h3c->table;

  640.     if (dt->ack_insert_count < insert_count) {
  641.         dt->ack_insert_count = insert_count;
  642.     }
  643. }


  646. static void
  647. ‌ngx_http_v3_unblock(void *data)
  648. {
  649.     ngx_http_v3_block_t  *block = data;

  651.     if (block->queue.prev) {
  652.         ngx_queue_remove(&block->queue);
  653.         block->queue.prev = NULL;
  654.         (*block->nblocked)--;
  655.     }
  656. }


  659. static ngx_int_t
  660. ‌ngx_http_v3_new_entry(ngx_connection_t *c)
  661. {
  662.     ngx_queue_t            *q;
  663.     ngx_connection_t       *bc;
  664.     ngx_http_v3_block_t    *block;
  665.     ngx_http_v3_session_t  *h3c;

  667.     h3c = ngx_http_v3_get_session(c);

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

  672.     while (!ngx_queue_empty(&h3c->blocked)) {
  673.         q = ngx_queue_head(&h3c->blocked);
  674.         block = (ngx_http_v3_block_t *) q;
  675.         bc = block->connection;

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

  679.         ngx_http_v3_unblock(block);
  680.         ngx_post_event(bc->read, &ngx_posted_events);
  681.     }

  683.     return NGX_OK;
  684. }


  687. ngx_int_t
  688. ‌ngx_http_v3_set_param(ngx_connection_t *c, uint64_t id, uint64_t value)
  689. {
  690.     switch (id) {

  692.     case NGX_HTTP_V3_PARAM_MAX_TABLE_CAPACITY:
  693.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  694.                        "http3 param QPACK_MAX_TABLE_CAPACITY:%uL", value);
  695.         break;

  697.     case NGX_HTTP_V3_PARAM_MAX_FIELD_SECTION_SIZE:
  698.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  699.                        "http3 param SETTINGS_MAX_FIELD_SECTION_SIZE:%uL",
  700.                        value);
  701.         break;

  703.     case NGX_HTTP_V3_PARAM_BLOCKED_STREAMS:
  704.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  705.                        "http3 param QPACK_BLOCKED_STREAMS:%uL", value);
  706.         break;

  708.     default:

  710.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  711.                        "http3 param #%uL:%uL", id, value);
  712.     }

  714.     return NGX_OK;
  715. }

One Level Up Top Level