One Level Up Top Level

src/http/v3/ngx_http_v3_table.c - nginx

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_dynamic_table_t  *dt;

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

  167.     if (dt->insert_buffer == NULL) {
  168.         dt->insert_buffer = ngx_create_temp_buf(c->pool, dt->capacity);
  169.         if (dt->insert_buffer == NULL) {
  170.             return NULL;
  171.         }
  172.     }

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

  176.     return dt->insert_buffer;
  177. }


  180. ngx_int_t
  181. ‌ngx_http_v3_ref_insert(ngx_connection_t *c, ngx_uint_t dynamic,
  182.     ngx_uint_t index, ngx_str_t *value)
  183. {
  184.     ngx_str_t                     name;
  185.     ngx_http_v3_session_t        *h3c;
  186.     ngx_http_v3_dynamic_table_t  *dt;

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

  192.         h3c = ngx_http_v3_get_session(c);
  193.         dt = &h3c->table;

  195.         if (dt->base + dt->nelts <= index) {
  196.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  197.         }

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

  201.         if (ngx_http_v3_lookup(c, index, &name, NULL) != NGX_OK) {
  202.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  203.         }

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

  209.         if (ngx_http_v3_lookup_static(c, index, &name, NULL) != NGX_OK) {
  210.             return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  211.         }
  212.     }

  214.     return ngx_http_v3_insert(c, &name, value);
  215. }


  218. ngx_int_t
  219. ‌ngx_http_v3_insert(ngx_connection_t *c, ngx_str_t *name, ngx_str_t *value)
  220. {
  221.     u_char                       *p;
  222.     size_t                        size;
  223.     ngx_http_v3_field_t          *field;
  224.     ngx_http_v3_session_t        *h3c;
  225.     ngx_http_v3_dynamic_table_t  *dt;

  227.     size = ngx_http_v3_table_entry_size(name, value);

  229.     h3c = ngx_http_v3_get_session(c);
  230.     dt = &h3c->table;

  232.     if (size > dt->capacity) {
  233.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  234.                       "not enough dynamic table capacity");
  235.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  236.     }

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

  242.     p = ngx_alloc(sizeof(ngx_http_v3_field_t) + name->len + value->len,
  243.                   c->log);
  244.     if (p == NULL) {
  245.         return NGX_ERROR;
  246.     }

  248.     field = (ngx_http_v3_field_t *) p;

  250.     field->name.data = p + sizeof(ngx_http_v3_field_t);
  251.     field->name.len = name->len;
  252.     field->value.data = ngx_cpymem(field->name.data, name->data, name->len);
  253.     field->value.len = value->len;
  254.     ngx_memcpy(field->value.data, value->data, value->len);

  256.     dt->elts[dt->nelts++] = field;
  257.     dt->size += size;

  259.     dt->insert_count++;

  261.     if (ngx_http_v3_evict(c, dt->capacity) != NGX_OK) {
  262.         return NGX_ERROR;
  263.     }

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

  267.     if (ngx_http_v3_new_entry(c) != NGX_OK) {
  268.         return NGX_ERROR;
  269.     }

  271.     return NGX_OK;
  272. }


  275. void
  276. ‌ngx_http_v3_inc_insert_count_handler(ngx_event_t *ev)
  277. {
  278.     ngx_connection_t             *c;
  279.     ngx_http_v3_session_t        *h3c;
  280.     ngx_http_v3_dynamic_table_t  *dt;

  282.     c = ev->data;

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

  287.     h3c = ngx_http_v3_get_session(c);
  288.     dt = &h3c->table;

  290.     if (dt->insert_count > dt->ack_insert_count) {
  291.         if (ngx_http_v3_send_inc_insert_count(c,
  292.                                        dt->insert_count - dt->ack_insert_count)
  293.             != NGX_OK)
  294.         {
  295.             return;
  296.         }

  298.         dt->ack_insert_count = dt->insert_count;
  299.     }
  300. }


  303. ngx_int_t
  304. ‌ngx_http_v3_set_capacity(ngx_connection_t *c, ngx_uint_t capacity)
  305. {
  306.     ngx_uint_t                     max, prev_max;
  307.     ngx_http_v3_field_t          **elts;
  308.     ngx_http_v3_session_t         *h3c;
  309.     ngx_http_v3_srv_conf_t        *h3scf;
  310.     ngx_http_v3_dynamic_table_t   *dt;

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

  315.     h3c = ngx_http_v3_get_session(c);
  316.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  318.     if (capacity > h3scf->max_table_capacity) {
  319.         ngx_log_error(NGX_LOG_INFO, c->log, 0,
  320.                       "client exceeded http3_max_table_capacity limit");
  321.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  322.     }

  324.     if (ngx_http_v3_evict(c, capacity) != NGX_OK) {
  325.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  326.     }

  328.     dt = &h3c->table;
  329.     max = capacity / 32;
  330.     prev_max = dt->capacity / 32;

  332.     if (max > prev_max) {
  333.         elts = ngx_alloc((max + 1) * sizeof(void *), c->log);
  334.         if (elts == NULL) {
  335.             return NGX_ERROR;
  336.         }

  338.         if (dt->elts) {
  339.             ngx_memcpy(elts, dt->elts, dt->nelts * sizeof(void *));
  340.             ngx_free(dt->elts);
  341.         }

  343.         dt->elts = elts;
  344.     }

  346.     dt->capacity = capacity;

  348.     return NGX_OK;
  349. }


  352. void
  353. ‌ngx_http_v3_cleanup_table(ngx_http_v3_session_t *h3c)
  354. {
  355.     ngx_uint_t                    n;
  356.     ngx_http_v3_dynamic_table_t  *dt;

  358.     dt = &h3c->table;

  360.     if (dt->elts == NULL) {
  361.         return;
  362.     }

  364.     for (n = 0; n < dt->nelts; n++) {
  365.         ngx_free(dt->elts[n]);
  366.     }

  368.     ngx_free(dt->elts);
  369. }


  372. static ngx_int_t
  373. ‌ngx_http_v3_evict(ngx_connection_t *c, size_t target)
  374. {
  375.     size_t                        size;
  376.     ngx_uint_t                    n;
  377.     ngx_http_v3_field_t          *field;
  378.     ngx_http_v3_session_t        *h3c;
  379.     ngx_http_v3_dynamic_table_t  *dt;

  381.     h3c = ngx_http_v3_get_session(c);
  382.     dt = &h3c->table;
  383.     n = 0;

  385.     while (dt->size > target) {
  386.         field = dt->elts[n++];
  387.         size = ngx_http_v3_table_entry_size(&field->name, &field->value);

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

  393.         ngx_free(field);
  394.         dt->size -= size;
  395.     }

  397.     if (n) {
  398.         dt->nelts -= n;
  399.         dt->base += n;
  400.         ngx_memmove(dt->elts, &dt->elts[n], dt->nelts * sizeof(void *));
  401.     }

  403.     return NGX_OK;
  404. }


  407. ngx_int_t
  408. ‌ngx_http_v3_duplicate(ngx_connection_t *c, ngx_uint_t index)
  409. {
  410.     ngx_str_t                     name, value;
  411.     ngx_http_v3_session_t        *h3c;
  412.     ngx_http_v3_dynamic_table_t  *dt;

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

  416.     h3c = ngx_http_v3_get_session(c);
  417.     dt = &h3c->table;

  419.     if (dt->base + dt->nelts <= index) {
  420.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  421.     }

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

  425.     if (ngx_http_v3_lookup(c, index, &name, &value) != NGX_OK) {
  426.         return NGX_HTTP_V3_ERR_ENCODER_STREAM_ERROR;
  427.     }

  429.     return ngx_http_v3_insert(c, &name, &value);
  430. }


  433. ngx_int_t
  434. ‌ngx_http_v3_ack_section(ngx_connection_t *c, ngx_uint_t stream_id)
  435. {
  436.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  437.                    "http3 ack section %ui", stream_id);

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

  441.     return NGX_HTTP_V3_ERR_DECODER_STREAM_ERROR;
  442. }


  445. ngx_int_t
  446. ‌ngx_http_v3_inc_insert_count(ngx_connection_t *c, ngx_uint_t inc)
  447. {
  448.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  449.                    "http3 increment insert count %ui", inc);

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

  453.     return NGX_HTTP_V3_ERR_DECODER_STREAM_ERROR;
  454. }


  457. ngx_int_t
  458. ‌ngx_http_v3_lookup_static(ngx_connection_t *c, ngx_uint_t index,
  459.     ngx_str_t *name, ngx_str_t *value)
  460. {
  461.     ngx_uint_t            nelts;
  462.     ngx_http_v3_field_t  *field;

  464.     nelts = sizeof(ngx_http_v3_static_table)
  465.             / sizeof(ngx_http_v3_static_table[0]);

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

  474.     field = &ngx_http_v3_static_table[index];

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

  480.     if (name) {
  481.         *name = field->name;
  482.     }

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

  488.     return NGX_OK;
  489. }


  492. ngx_int_t
  493. ‌ngx_http_v3_lookup(ngx_connection_t *c, ngx_uint_t index, ngx_str_t *name,
  494.     ngx_str_t *value)
  495. {
  496.     ngx_http_v3_field_t          *field;
  497.     ngx_http_v3_session_t        *h3c;
  498.     ngx_http_v3_dynamic_table_t  *dt;

  500.     h3c = ngx_http_v3_get_session(c);
  501.     dt = &h3c->table;

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

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

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

  516.     if (name) {
  517.         *name = field->name;
  518.     }

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

  524.     return NGX_OK;
  525. }


  528. ngx_int_t
  529. ‌ngx_http_v3_decode_insert_count(ngx_connection_t *c, ngx_uint_t *insert_count)
  530. {
  531.     ngx_uint_t                    max_entries, full_range, max_value,
  532.                                   max_wrapped, req_insert_count;
  533.     ngx_http_v3_srv_conf_t       *h3scf;
  534.     ngx_http_v3_session_t        *h3c;
  535.     ngx_http_v3_dynamic_table_t  *dt;

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

  539.     if (*insert_count == 0) {
  540.         return NGX_OK;
  541.     }

  543.     h3c = ngx_http_v3_get_session(c);
  544.     dt = &h3c->table;

  546.     h3scf = ngx_http_v3_get_module_srv_conf(c, ngx_http_v3_module);

  548.     max_entries = h3scf->max_table_capacity / 32;
  549.     full_range = 2 * max_entries;

  551.     if (*insert_count > full_range) {
  552.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  553.     }

  555.     max_value = dt->base + dt->nelts + max_entries;
  556.     max_wrapped = (max_value / full_range) * full_range;
  557.     req_insert_count = max_wrapped + *insert_count - 1;

  559.     if (req_insert_count > max_value) {
  560.         if (req_insert_count <= full_range) {
  561.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  562.         }

  564.         req_insert_count -= full_range;
  565.     }

  567.     if (req_insert_count == 0) {
  568.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  569.     }

  571.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  572.                    "http3 decode insert_count %ui -> %ui",
  573.                    *insert_count, req_insert_count);

  575.     *insert_count = req_insert_count;

  577.     return NGX_OK;
  578. }


  581. ngx_int_t
  582. ‌ngx_http_v3_check_insert_count(ngx_connection_t *c, ngx_uint_t insert_count)
  583. {
  584.     size_t                        n;
  585.     ngx_pool_cleanup_t           *cln;
  586.     ngx_http_v3_block_t          *block;
  587.     ngx_http_v3_session_t        *h3c;
  588.     ngx_http_v3_srv_conf_t       *h3scf;
  589.     ngx_http_v3_dynamic_table_t  *dt;

  591.     h3c = ngx_http_v3_get_session(c);
  592.     dt = &h3c->table;

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

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

  600.     if (n >= insert_count) {
  601.         return NGX_OK;
  602.     }

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

  606.     block = NULL;

  608.     for (cln = c->pool->cleanup; cln; cln = cln->next) {
  609.         if (cln->handler == ngx_http_v3_unblock) {
  610.             block = cln->data;
  611.             break;
  612.         }
  613.     }

  615.     if (block == NULL) {
  616.         cln = ngx_pool_cleanup_add(c->pool, sizeof(ngx_http_v3_block_t));
  617.         if (cln == NULL) {
  618.             return NGX_ERROR;
  619.         }

  621.         cln->handler = ngx_http_v3_unblock;

  623.         block = cln->data;
  624.         block->queue.prev = NULL;
  625.         block->connection = c;
  626.         block->nblocked = &h3c->nblocked;
  627.     }

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

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

  636.             ngx_http_v3_finalize_connection(c,
  637.                                           NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED,
  638.                                           "too many blocked streams");
  639.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  640.         }

  642.         h3c->nblocked++;
  643.         ngx_queue_insert_tail(&h3c->blocked, &block->queue);
  644.     }

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

  649.     return NGX_BUSY;
  650. }


  653. void
  654. ‌ngx_http_v3_ack_insert_count(ngx_connection_t *c, uint64_t insert_count)
  655. {
  656.     ngx_http_v3_session_t        *h3c;
  657.     ngx_http_v3_dynamic_table_t  *dt;

  659.     h3c = ngx_http_v3_get_session(c);
  660.     dt = &h3c->table;

  662.     if (dt->ack_insert_count < insert_count) {
  663.         dt->ack_insert_count = insert_count;
  664.     }
  665. }


  668. static void
  669. ‌ngx_http_v3_unblock(void *data)
  670. {
  671.     ngx_http_v3_block_t  *block = data;

  673.     if (block->queue.prev) {
  674.         ngx_queue_remove(&block->queue);
  675.         block->queue.prev = NULL;
  676.         (*block->nblocked)--;
  677.     }
  678. }


  681. static ngx_int_t
  682. ‌ngx_http_v3_new_entry(ngx_connection_t *c)
  683. {
  684.     ngx_queue_t            *q;
  685.     ngx_connection_t       *bc;
  686.     ngx_http_v3_block_t    *block;
  687.     ngx_http_v3_session_t  *h3c;

  689.     h3c = ngx_http_v3_get_session(c);

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

  694.     while (!ngx_queue_empty(&h3c->blocked)) {
  695.         q = ngx_queue_head(&h3c->blocked);
  696.         block = (ngx_http_v3_block_t *) q;
  697.         bc = block->connection;

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

  701.         ngx_http_v3_unblock(block);
  702.         ngx_post_event(bc->read, &ngx_posted_events);
  703.     }

  705.     return NGX_OK;
  706. }


  709. ngx_int_t
  710. ‌ngx_http_v3_set_param(ngx_connection_t *c, uint64_t id, uint64_t value)
  711. {
  712.     switch (id) {

  714.     case NGX_HTTP_V3_PARAM_MAX_TABLE_CAPACITY:
  715.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  716.                        "http3 param QPACK_MAX_TABLE_CAPACITY:%uL", value);
  717.         break;

  719.     case NGX_HTTP_V3_PARAM_MAX_FIELD_SECTION_SIZE:
  720.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  721.                        "http3 param SETTINGS_MAX_FIELD_SECTION_SIZE:%uL",
  722.                        value);
  723.         break;

  725.     case NGX_HTTP_V3_PARAM_BLOCKED_STREAMS:
  726.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  727.                        "http3 param QPACK_BLOCKED_STREAMS:%uL", value);
  728.         break;

  730.     default:

  732.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  733.                        "http3 param #%uL:%uL", id, value);
  734.     }

  736.     return NGX_OK;
  737. }

One Level Up Top Level