One Level Up Top Level

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

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_is_v2_frame(type)                                         \
  14.     ((type) == 0x02 || (type) == 0x06 || (type) == 0x08 || (type) == 0x09)


  17. static void ngx_http_v3_parse_start_local(ngx_buf_t *b, ngx_buf_t *loc,
  18.     ngx_uint_t n);
  19. static void ngx_http_v3_parse_end_local(ngx_buf_t *b, ngx_buf_t *loc,
  20.     ngx_uint_t *n);
  21. static ngx_int_t ngx_http_v3_parse_skip(ngx_buf_t *b, ngx_uint_t *length);

  23. static ngx_int_t ngx_http_v3_parse_varlen_int(ngx_connection_t *c,
  24.     ngx_http_v3_parse_varlen_int_t *st, ngx_buf_t *b);
  25. static ngx_int_t ngx_http_v3_parse_prefix_int(ngx_connection_t *c,
  26.     ngx_http_v3_parse_prefix_int_t *st, ngx_uint_t prefix, ngx_buf_t *b);

  28. static ngx_int_t ngx_http_v3_parse_field_section_prefix(ngx_connection_t *c,
  29.     ngx_http_v3_parse_field_section_prefix_t *st, ngx_buf_t *b);
  30. static ngx_int_t ngx_http_v3_parse_field_rep(ngx_connection_t *c,
  31.     ngx_http_v3_parse_field_rep_t *st, ngx_uint_t base, ngx_buf_t *b);
  32. static ngx_int_t ngx_http_v3_parse_literal(ngx_connection_t *c,
  33.     ngx_http_v3_parse_literal_t *st, ngx_buf_t *b);
  34. static ngx_int_t ngx_http_v3_parse_field_ri(ngx_connection_t *c,
  35.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);
  36. static ngx_int_t ngx_http_v3_parse_field_lri(ngx_connection_t *c,
  37.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);
  38. static ngx_int_t ngx_http_v3_parse_field_l(ngx_connection_t *c,
  39.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);
  40. static ngx_int_t ngx_http_v3_parse_field_pbi(ngx_connection_t *c,
  41.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);
  42. static ngx_int_t ngx_http_v3_parse_field_lpbi(ngx_connection_t *c,
  43.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);

  45. static ngx_int_t ngx_http_v3_parse_control(ngx_connection_t *c,
  46.     ngx_http_v3_parse_control_t *st, ngx_buf_t *b);
  47. static ngx_int_t ngx_http_v3_parse_settings(ngx_connection_t *c,
  48.     ngx_http_v3_parse_settings_t *st, ngx_buf_t *b);

  50. static ngx_int_t ngx_http_v3_parse_encoder(ngx_connection_t *c,
  51.     ngx_http_v3_parse_encoder_t *st, ngx_buf_t *b);
  52. static ngx_int_t ngx_http_v3_parse_field_inr(ngx_connection_t *c,
  53.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);
  54. static ngx_int_t ngx_http_v3_parse_field_iln(ngx_connection_t *c,
  55.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b);

  57. static ngx_int_t ngx_http_v3_parse_decoder(ngx_connection_t *c,
  58.     ngx_http_v3_parse_decoder_t *st, ngx_buf_t *b);

  60. static ngx_int_t ngx_http_v3_parse_lookup(ngx_connection_t *c,
  61.     ngx_uint_t dynamic, ngx_uint_t index, ngx_str_t *name, ngx_str_t *value);


  64. static void
  65. ‌ngx_http_v3_parse_start_local(ngx_buf_t *b, ngx_buf_t *loc, ngx_uint_t n)
  66. {
  67.     *loc = *b;

  69.     if ((size_t) (loc->last - loc->pos) > n) {
  70.         loc->last = loc->pos + n;
  71.     }
  72. }


  75. static void
  76. ‌ngx_http_v3_parse_end_local(ngx_buf_t *b, ngx_buf_t *loc, ngx_uint_t *pn)
  77. {
  78.     *pn -= loc->pos - b->pos;
  79.     b->pos = loc->pos;
  80. }


  83. static ngx_int_t
  84. ‌ngx_http_v3_parse_skip(ngx_buf_t *b, ngx_uint_t *length)
  85. {
  86.     if ((size_t) (b->last - b->pos) < *length) {
  87.         *length -= b->last - b->pos;
  88.         b->pos = b->last;
  89.         return NGX_AGAIN;
  90.     }

  92.     b->pos += *length;
  93.     return NGX_DONE;
  94. }


  97. static ngx_int_t
  98. ‌ngx_http_v3_parse_varlen_int(ngx_connection_t *c,
  99.     ngx_http_v3_parse_varlen_int_t *st, ngx_buf_t *b)
  100. {
  101.     u_char  ch;
  102. ‌    enum {
  103.         sw_start = 0,
  104.         sw_length_2,
  105.         sw_length_3,
  106.         sw_length_4,
  107.         sw_length_5,
  108.         sw_length_6,
  109.         sw_length_7,
  110.         sw_length_8
  111.     };

  113.     for ( ;; ) {

  115.         if (b->pos == b->last) {
  116.             return NGX_AGAIN;
  117.         }

  119.         ch = *b->pos++;

  121.         switch (st->state) {

  123.         case sw_start:

  125.             st->value = ch;
  126.             if (st->value & 0xc0) {
  127.                 st->state = sw_length_2;
  128.                 break;
  129.             }

  131.             goto done;

  133.         case sw_length_2:

  135.             st->value = (st->value << 8) + ch;
  136.             if ((st->value & 0xc000) == 0x4000) {
  137.                 st->value &= 0x3fff;
  138.                 goto done;
  139.             }

  141.             st->state = sw_length_3;
  142.             break;

  144.         case sw_length_4:

  146.             st->value = (st->value << 8) + ch;
  147.             if ((st->value & 0xc0000000) == 0x80000000) {
  148.                 st->value &= 0x3fffffff;
  149.                 goto done;
  150.             }

  152.             st->state = sw_length_5;
  153.             break;

  155.         case sw_length_3:
  156.         case sw_length_5:
  157.         case sw_length_6:
  158.         case sw_length_7:

  160.             st->value = (st->value << 8) + ch;
  161.             st->state++;
  162.             break;

  164.         case sw_length_8:

  166.             st->value = (st->value << 8) + ch;
  167.             st->value &= 0x3fffffffffffffff;
  168.             goto done;
  169.         }
  170.     }

  172. done:

  174.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  175.                    "http3 parse varlen int %uL", st->value);

  177.     st->state = sw_start;
  178.     return NGX_DONE;
  179. }


  182. static ngx_int_t
  183. ‌ngx_http_v3_parse_prefix_int(ngx_connection_t *c,
  184.     ngx_http_v3_parse_prefix_int_t *st, ngx_uint_t prefix, ngx_buf_t *b)
  185. {
  186.     u_char      ch;
  187.     ngx_uint_t  mask;
  188. ‌    enum {
  189.         sw_start = 0,
  190.         sw_value
  191.     };

  193.     for ( ;; ) {

  195.         if (b->pos == b->last) {
  196.             return NGX_AGAIN;
  197.         }

  199.         ch = *b->pos++;

  201.         switch (st->state) {

  203.         case sw_start:

  205.             mask = (1 << prefix) - 1;
  206.             st->value = ch & mask;

  208.             if (st->value != mask) {
  209.                 goto done;
  210.             }

  212.             st->shift = 0;
  213.             st->state = sw_value;
  214.             break;

  216.         case sw_value:

  218.             st->value += (uint64_t) (ch & 0x7f) << st->shift;

  220.             if (st->shift == 56
  221.                 && ((ch & 0x80) || (st->value & 0xc000000000000000)))
  222.             {
  223.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  224.                               "client exceeded integer size limit");
  225.                 return NGX_HTTP_V3_ERR_EXCESSIVE_LOAD;
  226.             }

  228.             if (ch & 0x80) {
  229.                 st->shift += 7;
  230.                 break;
  231.             }

  233.             goto done;
  234.         }
  235.     }

  237. done:

  239.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  240.                    "http3 parse prefix int %uL", st->value);

  242.     st->state = sw_start;
  243.     return NGX_DONE;
  244. }


  247. ngx_int_t
  248. ‌ngx_http_v3_parse_headers(ngx_connection_t *c, ngx_http_v3_parse_headers_t *st,
  249.     ngx_buf_t *b)
  250. {
  251.     ngx_buf_t  loc;
  252.     ngx_int_t  rc;
  253. ‌    enum {
  254.         sw_start = 0,
  255.         sw_type,
  256.         sw_length,
  257.         sw_skip,
  258.         sw_prefix,
  259.         sw_verify,
  260.         sw_field_rep,
  261.         sw_done
  262.     };

  264.     for ( ;; ) {

  266.         switch (st->state) {

  268.         case sw_start:

  270.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  271.                            "http3 parse headers");

  273.             st->state = sw_type;

  275.             /* fall through */

  277.         case sw_type:

  279.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  280.             if (rc != NGX_DONE) {
  281.                 return rc;
  282.             }

  284.             st->type = st->vlint.value;

  286.             if (ngx_http_v3_is_v2_frame(st->type)
  287.                 || st->type == NGX_HTTP_V3_FRAME_DATA
  288.                 || st->type == NGX_HTTP_V3_FRAME_GOAWAY
  289.                 || st->type == NGX_HTTP_V3_FRAME_SETTINGS
  290.                 || st->type == NGX_HTTP_V3_FRAME_MAX_PUSH_ID
  291.                 || st->type == NGX_HTTP_V3_FRAME_CANCEL_PUSH
  292.                 || st->type == NGX_HTTP_V3_FRAME_PUSH_PROMISE)
  293.             {
  294.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  295.             }

  297.             st->state = sw_length;
  298.             break;

  300.         case sw_length:

  302.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  303.             if (rc != NGX_DONE) {
  304.                 return rc;
  305.             }

  307.             st->length = st->vlint.value;

  309.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  310.                            "http3 parse headers type:%ui, len:%ui",
  311.                            st->type, st->length);

  313.             if (st->type != NGX_HTTP_V3_FRAME_HEADERS) {
  314.                 st->state = st->length > 0 ? sw_skip : sw_type;
  315.                 break;
  316.             }

  318.             if (st->length == 0) {
  319.                 return NGX_HTTP_V3_ERR_FRAME_ERROR;
  320.             }

  322.             st->state = sw_prefix;
  323.             break;

  325.         case sw_skip:

  327.             rc = ngx_http_v3_parse_skip(b, &st->length);
  328.             if (rc != NGX_DONE) {
  329.                 return rc;
  330.             }

  332.             st->state = sw_type;
  333.             break;

  335.         case sw_prefix:

  337.             ngx_http_v3_parse_start_local(b, &loc, st->length);

  339.             rc = ngx_http_v3_parse_field_section_prefix(c, &st->prefix, &loc);

  341.             ngx_http_v3_parse_end_local(b, &loc, &st->length);

  343.             if (st->length == 0 && rc == NGX_AGAIN) {
  344.                 return NGX_HTTP_V3_ERR_FRAME_ERROR;
  345.             }

  347.             if (rc != NGX_DONE) {
  348.                 return rc;
  349.             }

  351.             st->state = sw_verify;
  352.             break;

  354.         case sw_verify:

  356.             rc = ngx_http_v3_check_insert_count(c, st->prefix.insert_count);
  357.             if (rc != NGX_OK) {
  358.                 return rc;
  359.             }

  361.             st->state = sw_field_rep;

  363.             /* fall through */

  365.         case sw_field_rep:

  367.             ngx_http_v3_parse_start_local(b, &loc, st->length);

  369.             rc = ngx_http_v3_parse_field_rep(c, &st->field_rep, st->prefix.base,
  370.                                              &loc);

  372.             ngx_http_v3_parse_end_local(b, &loc, &st->length);

  374.             if (st->length == 0 && rc == NGX_AGAIN) {
  375.                 return NGX_HTTP_V3_ERR_FRAME_ERROR;
  376.             }

  378.             if (rc != NGX_DONE) {
  379.                 return rc;
  380.             }

  382.             if (st->length == 0) {
  383.                 goto done;
  384.             }

  386.             return NGX_OK;
  387.         }
  388.     }

  390. done:

  392.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse headers done");

  394.     if (st->prefix.insert_count > 0) {
  395.         if (ngx_http_v3_send_ack_section(c, c->quic->id) != NGX_OK) {
  396.             return NGX_ERROR;
  397.         }

  399.         ngx_http_v3_ack_insert_count(c, st->prefix.insert_count);
  400.     }

  402.     st->state = sw_start;
  403.     return NGX_DONE;
  404. }


  407. static ngx_int_t
  408. ‌ngx_http_v3_parse_field_section_prefix(ngx_connection_t *c,
  409.     ngx_http_v3_parse_field_section_prefix_t *st, ngx_buf_t *b)
  410. {
  411.     u_char     ch;
  412.     ngx_int_t  rc;
  413. ‌    enum {
  414.         sw_start = 0,
  415.         sw_req_insert_count,
  416.         sw_delta_base,
  417.         sw_read_delta_base
  418.     };

  420.     for ( ;; ) {

  422.         switch (st->state) {

  424.         case sw_start:

  426.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  427.                            "http3 parse field section prefix");

  429.             st->state = sw_req_insert_count;

  431.             /* fall through */

  433.         case sw_req_insert_count:

  435.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 8, b);
  436.             if (rc != NGX_DONE) {
  437.                 return rc;
  438.             }

  440.             st->insert_count = st->pint.value;
  441.             st->state = sw_delta_base;
  442.             break;

  444.         case sw_delta_base:

  446.             if (b->pos == b->last) {
  447.                 return NGX_AGAIN;
  448.             }

  450.             ch = *b->pos;

  452.             st->sign = (ch & 0x80) ? 1 : 0;
  453.             st->state = sw_read_delta_base;

  455.             /* fall through */

  457.         case sw_read_delta_base:

  459.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  460.             if (rc != NGX_DONE) {
  461.                 return rc;
  462.             }

  464.             st->delta_base = st->pint.value;
  465.             goto done;
  466.         }
  467.     }

  469. done:

  471.     rc = ngx_http_v3_decode_insert_count(c, &st->insert_count);
  472.     if (rc != NGX_OK) {
  473.         return rc;
  474.     }

  476.     if (st->sign) {
  477.         if (st->insert_count <= st->delta_base) {
  478.             ngx_log_error(NGX_LOG_INFO, c->log, 0, "client sent negative base");
  479.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  480.         }

  482.         st->base = st->insert_count - st->delta_base - 1;

  484.     } else {
  485.         st->base = st->insert_count + st->delta_base;
  486.     }

  488.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, c->log, 0,
  489.                   "http3 parse field section prefix done "
  490.                   "insert_count:%ui, sign:%ui, delta_base:%ui, base:%ui",
  491.                   st->insert_count, st->sign, st->delta_base, st->base);

  493.     st->state = sw_start;
  494.     return NGX_DONE;
  495. }


  498. static ngx_int_t
  499. ‌ngx_http_v3_parse_field_rep(ngx_connection_t *c,
  500.     ngx_http_v3_parse_field_rep_t *st, ngx_uint_t base, ngx_buf_t *b)
  501. {
  502.     u_char     ch;
  503.     ngx_int_t  rc;
  504. ‌    enum {
  505.         sw_start = 0,
  506.         sw_field_ri,
  507.         sw_field_lri,
  508.         sw_field_l,
  509.         sw_field_pbi,
  510.         sw_field_lpbi
  511.     };

  513.     if (st->state == sw_start) {

  515.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  516.                        "http3 parse field representation");

  518.         if (b->pos == b->last) {
  519.             return NGX_AGAIN;
  520.         }

  522.         ch = *b->pos;

  524.         ngx_memzero(&st->field, sizeof(ngx_http_v3_parse_field_t));

  526.         st->field.base = base;

  528.         if (ch & 0x80) {
  529.             /* Indexed Field Line */

  531.             st->state = sw_field_ri;

  533.         } else if (ch & 0x40) {
  534.             /* Literal Field Line With Name Reference */

  536.             st->state = sw_field_lri;

  538.         } else if (ch & 0x20) {
  539.             /* Literal Field Line With Literal Name */

  541.             st->state = sw_field_l;

  543.         } else if (ch & 0x10) {
  544.             /* Indexed Field Line With Post-Base Index */

  546.             st->state = sw_field_pbi;

  548.         } else {
  549.             /* Literal Field Line With Post-Base Name Reference */

  551.             st->state = sw_field_lpbi;
  552.         }
  553.     }

  555.     switch (st->state) {

  557.     case sw_field_ri:
  558.         rc = ngx_http_v3_parse_field_ri(c, &st->field, b);
  559.         break;

  561.     case sw_field_lri:
  562.         rc = ngx_http_v3_parse_field_lri(c, &st->field, b);
  563.         break;

  565.     case sw_field_l:
  566.         rc = ngx_http_v3_parse_field_l(c, &st->field, b);
  567.         break;

  569.     case sw_field_pbi:
  570.         rc = ngx_http_v3_parse_field_pbi(c, &st->field, b);
  571.         break;

  573.     case sw_field_lpbi:
  574.         rc = ngx_http_v3_parse_field_lpbi(c, &st->field, b);
  575.         break;

  577.     default:
  578.         rc = NGX_OK;
  579.     }

  581.     if (rc != NGX_DONE) {
  582.         return rc;
  583.     }

  585.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  586.                    "http3 parse field representation done");

  588.     st->state = sw_start;
  589.     return NGX_DONE;
  590. }


  593. static ngx_int_t
  594. ‌ngx_http_v3_parse_literal(ngx_connection_t *c, ngx_http_v3_parse_literal_t *st,
  595.     ngx_buf_t *b)
  596. {
  597.     u_char                     ch;
  598.     ngx_uint_t                 n;
  599.     ngx_http_core_srv_conf_t  *cscf;
  600. ‌    enum {
  601.         sw_start = 0,
  602.         sw_value
  603.     };

  605.     for ( ;; ) {

  607.         switch (st->state) {

  609.         case sw_start:

  611.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  612.                            "http3 parse literal huff:%ui, len:%ui",
  613.                            st->huffman, st->length);

  615.             n = st->length;

  617.             cscf = ngx_http_v3_get_module_srv_conf(c, ngx_http_core_module);

  619.             if (n > cscf->large_client_header_buffers.size) {
  620.                 ngx_log_error(NGX_LOG_INFO, c->log, 0,
  621.                               "client sent too large field line");
  622.                 return NGX_HTTP_V3_ERR_EXCESSIVE_LOAD;
  623.             }

  625.             if (st->huffman) {
  626.                 n = n * 8 / 5;
  627.                 st->huffstate = 0;
  628.             }

  630.             st->last = ngx_pnalloc(c->pool, n + 1);
  631.             if (st->last == NULL) {
  632.                 return NGX_ERROR;
  633.             }

  635.             st->value.data = st->last;
  636.             st->state = sw_value;

  638.             /* fall through */

  640.         case sw_value:

  642.             if (b->pos == b->last) {
  643.                 return NGX_AGAIN;
  644.             }

  646.             ch = *b->pos++;

  648.             if (st->huffman) {
  649.                 if (ngx_http_huff_decode(&st->huffstate, &ch, 1, &st->last,
  650.                                          st->length == 1, c->log)
  651.                     != NGX_OK)
  652.                 {
  653.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  654.                                   "client sent invalid encoded field line");
  655.                     return NGX_ERROR;
  656.                 }

  658.             } else {
  659.                 *st->last++ = ch;
  660.             }

  662.             if (--st->length) {
  663.                 break;
  664.             }

  666.             st->value.len = st->last - st->value.data;
  667.             *st->last = '\0';
  668.             goto done;
  669.         }
  670.     }

  672. done:

  674.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  675.                    "http3 parse literal done \"%V\"", &st->value);

  677.     st->state = sw_start;
  678.     return NGX_DONE;
  679. }


  682. static ngx_int_t
  683. ‌ngx_http_v3_parse_field_ri(ngx_connection_t *c, ngx_http_v3_parse_field_t *st,
  684.     ngx_buf_t *b)
  685. {
  686.     u_char     ch;
  687.     ngx_int_t  rc;
  688. ‌    enum {
  689.         sw_start = 0,
  690.         sw_index
  691.     };

  693.     for ( ;; ) {

  695.         switch (st->state) {

  697.         case sw_start:

  699.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  700.                            "http3 parse field ri");

  702.             if (b->pos == b->last) {
  703.                 return NGX_AGAIN;
  704.             }

  706.             ch = *b->pos;

  708.             st->dynamic = (ch & 0x40) ? 0 : 1;
  709.             st->state = sw_index;

  711.             /* fall through */

  713.         case sw_index:

  715.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  716.             if (rc != NGX_DONE) {
  717.                 return rc;
  718.             }

  720.             st->index = st->pint.value;
  721.             goto done;
  722.         }
  723.     }

  725. done:

  727.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  728.                    "http3 parse field ri done %s%ui]",
  729.                    st->dynamic ? "dynamic[-" : "static[", st->index);

  731.     if (st->dynamic) {
  732.         st->index = st->base - st->index - 1;
  733.     }

  735.     rc = ngx_http_v3_parse_lookup(c, st->dynamic, st->index, &st->name,
  736.                                   &st->value);
  737.     if (rc != NGX_OK) {
  738.         return rc;
  739.     }

  741.     st->state = sw_start;
  742.     return NGX_DONE;
  743. }


  746. static ngx_int_t
  747. ‌ngx_http_v3_parse_field_lri(ngx_connection_t *c,
  748.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  749. {
  750.     u_char     ch;
  751.     ngx_int_t  rc;
  752. ‌    enum {
  753.         sw_start = 0,
  754.         sw_index,
  755.         sw_value_len,
  756.         sw_read_value_len,
  757.         sw_value
  758.     };

  760.     for ( ;; ) {

  762.         switch (st->state) {

  764.         case sw_start:

  766.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  767.                            "http3 parse field lri");

  769.             if (b->pos == b->last) {
  770.                 return NGX_AGAIN;
  771.             }

  773.             ch = *b->pos;

  775.             st->dynamic = (ch & 0x10) ? 0 : 1;
  776.             st->state = sw_index;

  778.             /* fall through */

  780.         case sw_index:

  782.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 4, b);
  783.             if (rc != NGX_DONE) {
  784.                 return rc;
  785.             }

  787.             st->index = st->pint.value;
  788.             st->state = sw_value_len;
  789.             break;

  791.         case sw_value_len:

  793.             if (b->pos == b->last) {
  794.                 return NGX_AGAIN;
  795.             }

  797.             ch = *b->pos;

  799.             st->literal.huffman = (ch & 0x80) ? 1 : 0;
  800.             st->state = sw_read_value_len;

  802.             /* fall through */

  804.         case sw_read_value_len:

  806.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  807.             if (rc != NGX_DONE) {
  808.                 return rc;
  809.             }

  811.             st->literal.length = st->pint.value;
  812.             if (st->literal.length == 0) {
  813.                 st->value.data = (u_char *) "";
  814.                 goto done;
  815.             }

  817.             st->state = sw_value;
  818.             break;

  820.         case sw_value:

  822.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  823.             if (rc != NGX_DONE) {
  824.                 return rc;
  825.             }

  827.             st->value = st->literal.value;
  828.             goto done;
  829.         }
  830.     }

  832. done:

  834.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  835.                    "http3 parse field lri done %s%ui] \"%V\"",
  836.                    st->dynamic ? "dynamic[-" : "static[",
  837.                    st->index, &st->value);

  839.     if (st->dynamic) {
  840.         st->index = st->base - st->index - 1;
  841.     }

  843.     rc = ngx_http_v3_parse_lookup(c, st->dynamic, st->index, &st->name, NULL);
  844.     if (rc != NGX_OK) {
  845.         return rc;
  846.     }

  848.     st->state = sw_start;
  849.     return NGX_DONE;
  850. }


  853. static ngx_int_t
  854. ‌ngx_http_v3_parse_field_l(ngx_connection_t *c,
  855.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  856. {
  857.     u_char     ch;
  858.     ngx_int_t  rc;
  859. ‌    enum {
  860.         sw_start = 0,
  861.         sw_name_len,
  862.         sw_name,
  863.         sw_value_len,
  864.         sw_read_value_len,
  865.         sw_value
  866.     };

  868.     for ( ;; ) {

  870.         switch (st->state) {

  872.         case sw_start:

  874.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  875.                            "http3 parse field l");

  877.             if (b->pos == b->last) {
  878.                 return NGX_AGAIN;
  879.             }

  881.             ch = *b->pos;

  883.             st->literal.huffman = (ch & 0x08) ? 1 : 0;
  884.             st->state = sw_name_len;

  886.             /* fall through */

  888.         case sw_name_len:

  890.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 3, b);
  891.             if (rc != NGX_DONE) {
  892.                 return rc;
  893.             }

  895.             st->literal.length = st->pint.value;
  896.             if (st->literal.length == 0) {
  897.                 return NGX_ERROR;
  898.             }

  900.             st->state = sw_name;
  901.             break;

  903.         case sw_name:

  905.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  906.             if (rc != NGX_DONE) {
  907.                 return rc;
  908.             }

  910.             st->name = st->literal.value;
  911.             st->state = sw_value_len;
  912.             break;

  914.         case sw_value_len:

  916.             if (b->pos == b->last) {
  917.                 return NGX_AGAIN;
  918.             }

  920.             ch = *b->pos;

  922.             st->literal.huffman = (ch & 0x80) ? 1 : 0;
  923.             st->state = sw_read_value_len;

  925.             /* fall through */

  927.         case sw_read_value_len:

  929.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  930.             if (rc != NGX_DONE) {
  931.                 return rc;
  932.             }

  934.             st->literal.length = st->pint.value;
  935.             if (st->literal.length == 0) {
  936.                 st->value.data = (u_char *) "";
  937.                 goto done;
  938.             }

  940.             st->state = sw_value;
  941.             break;

  943.         case sw_value:

  945.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  946.             if (rc != NGX_DONE) {
  947.                 return rc;
  948.             }

  950.             st->value = st->literal.value;
  951.             goto done;
  952.         }
  953.     }

  955. done:

  957.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  958.                    "http3 parse field l done \"%V\" \"%V\"",
  959.                    &st->name, &st->value);

  961.     st->state = sw_start;
  962.     return NGX_DONE;
  963. }


  966. static ngx_int_t
  967. ‌ngx_http_v3_parse_field_pbi(ngx_connection_t *c,
  968.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  969. {
  970.     ngx_int_t  rc;
  971. ‌    enum {
  972.         sw_start = 0,
  973.         sw_index
  974.     };

  976.     for ( ;; ) {

  978.         switch (st->state) {

  980.         case sw_start:

  982.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  983.                            "http3 parse field pbi");

  985.             st->state = sw_index;

  987.             /* fall through */

  989.         case sw_index:

  991.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 4, b);
  992.             if (rc != NGX_DONE) {
  993.                 return rc;
  994.             }

  996.             st->index = st->pint.value;
  997.             goto done;
  998.         }
  999.     }

  1001. done:

  1003.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1004.                    "http3 parse field pbi done dynamic[+%ui]", st->index);

  1006.     rc = ngx_http_v3_parse_lookup(c, 1, st->base + st->index, &st->name,
  1007.                                   &st->value);
  1008.     if (rc != NGX_OK) {
  1009.         return rc;
  1010.     }

  1012.     st->state = sw_start;
  1013.     return NGX_DONE;
  1014. }


  1017. static ngx_int_t
  1018. ‌ngx_http_v3_parse_field_lpbi(ngx_connection_t *c,
  1019.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  1020. {
  1021.     u_char     ch;
  1022.     ngx_int_t  rc;
  1023. ‌    enum {
  1024.         sw_start = 0,
  1025.         sw_index,
  1026.         sw_value_len,
  1027.         sw_read_value_len,
  1028.         sw_value
  1029.     };

  1031.     for ( ;; ) {

  1033.         switch (st->state) {

  1035.         case sw_start:

  1037.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1038.                            "http3 parse field lpbi");

  1040.             st->state = sw_index;

  1042.             /* fall through */

  1044.         case sw_index:

  1046.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 3, b);
  1047.             if (rc != NGX_DONE) {
  1048.                 return rc;
  1049.             }

  1051.             st->index = st->pint.value;
  1052.             st->state = sw_value_len;
  1053.             break;

  1055.         case sw_value_len:

  1057.             if (b->pos == b->last) {
  1058.                 return NGX_AGAIN;
  1059.             }

  1061.             ch = *b->pos;

  1063.             st->literal.huffman = (ch & 0x80) ? 1 : 0;
  1064.             st->state = sw_read_value_len;

  1066.             /* fall through */

  1068.         case sw_read_value_len:

  1070.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1071.             if (rc != NGX_DONE) {
  1072.                 return rc;
  1073.             }

  1075.             st->literal.length = st->pint.value;
  1076.             if (st->literal.length == 0) {
  1077.                 st->value.data = (u_char *) "";
  1078.                 goto done;
  1079.             }

  1081.             st->state = sw_value;
  1082.             break;

  1084.         case sw_value:

  1086.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1087.             if (rc != NGX_DONE) {
  1088.                 return rc;
  1089.             }

  1091.             st->value = st->literal.value;
  1092.             goto done;
  1093.         }
  1094.     }

  1096. done:

  1098.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1099.                    "http3 parse field lpbi done dynamic[+%ui] \"%V\"",
  1100.                    st->index, &st->value);

  1102.     rc = ngx_http_v3_parse_lookup(c, 1, st->base + st->index, &st->name, NULL);
  1103.     if (rc != NGX_OK) {
  1104.         return rc;
  1105.     }

  1107.     st->state = sw_start;
  1108.     return NGX_DONE;
  1109. }


  1112. static ngx_int_t
  1113. ‌ngx_http_v3_parse_lookup(ngx_connection_t *c, ngx_uint_t dynamic,
  1114.     ngx_uint_t index, ngx_str_t *name, ngx_str_t *value)
  1115. {
  1116.     u_char  *p;

  1118.     if (!dynamic) {
  1119.         if (ngx_http_v3_lookup_static(c, index, name, value) != NGX_OK) {
  1120.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  1121.         }

  1123.         return NGX_OK;
  1124.     }

  1126.     if (ngx_http_v3_lookup(c, index, name, value) != NGX_OK) {
  1127.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  1128.     }

  1130.     if (name) {
  1131.         p = ngx_pnalloc(c->pool, name->len + 1);
  1132.         if (p == NULL) {
  1133.             return NGX_ERROR;
  1134.         }

  1136.         ngx_memcpy(p, name->data, name->len);
  1137.         p[name->len] = '\0';
  1138.         name->data = p;
  1139.     }

  1141.     if (value) {
  1142.         p = ngx_pnalloc(c->pool, value->len + 1);
  1143.         if (p == NULL) {
  1144.             return NGX_ERROR;
  1145.         }

  1147.         ngx_memcpy(p, value->data, value->len);
  1148.         p[value->len] = '\0';
  1149.         value->data = p;
  1150.     }

  1152.     return NGX_OK;
  1153. }


  1156. static ngx_int_t
  1157. ‌ngx_http_v3_parse_control(ngx_connection_t *c, ngx_http_v3_parse_control_t *st,
  1158.     ngx_buf_t *b)
  1159. {
  1160.     ngx_buf_t  loc;
  1161.     ngx_int_t  rc;
  1162. ‌    enum {
  1163.         sw_start = 0,
  1164.         sw_first_type,
  1165.         sw_type,
  1166.         sw_length,
  1167.         sw_settings,
  1168.         sw_skip
  1169.     };

  1171.     for ( ;; ) {

  1173.         switch (st->state) {

  1175.         case sw_start:

  1177.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1178.                            "http3 parse control");

  1180.             st->state = sw_first_type;

  1182.             /* fall through */

  1184.         case sw_first_type:
  1185.         case sw_type:

  1187.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1188.             if (rc != NGX_DONE) {
  1189.                 return rc;
  1190.             }

  1192.             st->type = st->vlint.value;

  1194.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1195.                            "http3 parse frame type:%ui", st->type);

  1197.             if (st->state == sw_first_type
  1198.                 && st->type != NGX_HTTP_V3_FRAME_SETTINGS)
  1199.             {
  1200.                 return NGX_HTTP_V3_ERR_MISSING_SETTINGS;
  1201.             }

  1203.             if (st->state != sw_first_type
  1204.                 && st->type == NGX_HTTP_V3_FRAME_SETTINGS)
  1205.             {
  1206.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  1207.             }

  1209.             if (ngx_http_v3_is_v2_frame(st->type)
  1210.                 || st->type == NGX_HTTP_V3_FRAME_DATA
  1211.                 || st->type == NGX_HTTP_V3_FRAME_HEADERS
  1212.                 || st->type == NGX_HTTP_V3_FRAME_PUSH_PROMISE)
  1213.             {
  1214.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  1215.             }

  1217.             if (st->type == NGX_HTTP_V3_FRAME_CANCEL_PUSH) {
  1218.                 return NGX_HTTP_V3_ERR_ID_ERROR;
  1219.             }

  1221.             st->state = sw_length;
  1222.             break;

  1224.         case sw_length:

  1226.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1227.             if (rc != NGX_DONE) {
  1228.                 return rc;
  1229.             }

  1231.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1232.                            "http3 parse frame len:%uL", st->vlint.value);

  1234.             st->length = st->vlint.value;
  1235.             if (st->length == 0) {
  1236.                 st->state = sw_type;
  1237.                 break;
  1238.             }

  1240.             switch (st->type) {

  1242.             case NGX_HTTP_V3_FRAME_SETTINGS:
  1243.                 st->state = sw_settings;
  1244.                 break;

  1246.             default:
  1247.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1248.                                "http3 parse skip unknown frame");
  1249.                 st->state = sw_skip;
  1250.             }

  1252.             break;

  1254.         case sw_settings:

  1256.             ngx_http_v3_parse_start_local(b, &loc, st->length);

  1258.             rc = ngx_http_v3_parse_settings(c, &st->settings, &loc);

  1260.             ngx_http_v3_parse_end_local(b, &loc, &st->length);

  1262.             if (st->length == 0 && rc == NGX_AGAIN) {
  1263.                 return NGX_HTTP_V3_ERR_SETTINGS_ERROR;
  1264.             }

  1266.             if (rc != NGX_DONE) {
  1267.                 return rc;
  1268.             }

  1270.             if (st->length == 0) {
  1271.                 st->state = sw_type;
  1272.             }

  1274.             break;

  1276.         case sw_skip:

  1278.             rc = ngx_http_v3_parse_skip(b, &st->length);
  1279.             if (rc != NGX_DONE) {
  1280.                 return rc;
  1281.             }

  1283.             st->state = sw_type;
  1284.             break;
  1285.         }
  1286.     }
  1287. }


  1290. static ngx_int_t
  1291. ‌ngx_http_v3_parse_settings(ngx_connection_t *c,
  1292.     ngx_http_v3_parse_settings_t *st, ngx_buf_t *b)
  1293. {
  1294.     ngx_int_t  rc;
  1295. ‌    enum {
  1296.         sw_start = 0,
  1297.         sw_id,
  1298.         sw_value
  1299.     };

  1301.     for ( ;; ) {

  1303.         switch (st->state) {

  1305.         case sw_start:

  1307.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1308.                            "http3 parse settings");

  1310.             st->state = sw_id;

  1312.             /* fall through */

  1314.         case sw_id:

  1316.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1317.             if (rc != NGX_DONE) {
  1318.                 return rc;
  1319.             }

  1321.             st->id = st->vlint.value;
  1322.             st->state = sw_value;
  1323.             break;

  1325.         case sw_value:

  1327.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1328.             if (rc != NGX_DONE) {
  1329.                 return rc;
  1330.             }

  1332.             if (ngx_http_v3_set_param(c, st->id, st->vlint.value) != NGX_OK) {
  1333.                 return NGX_HTTP_V3_ERR_SETTINGS_ERROR;
  1334.             }

  1336.             goto done;
  1337.         }
  1338.     }

  1340. done:

  1342.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse settings done");

  1344.     st->state = sw_start;
  1345.     return NGX_DONE;
  1346. }


  1349. static ngx_int_t
  1350. ‌ngx_http_v3_parse_encoder(ngx_connection_t *c, ngx_http_v3_parse_encoder_t *st,
  1351.     ngx_buf_t *b)
  1352. {
  1353.     u_char     ch;
  1354.     ngx_int_t  rc;
  1355. ‌    enum {
  1356.         sw_start = 0,
  1357.         sw_inr,
  1358.         sw_iln,
  1359.         sw_capacity,
  1360.         sw_duplicate
  1361.     };

  1363.     for ( ;; ) {

  1365.         if (st->state == sw_start) {

  1367.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1368.                            "http3 parse encoder instruction");

  1370.             if (b->pos == b->last) {
  1371.                 return NGX_AGAIN;
  1372.             }

  1374.             ch = *b->pos;

  1376.             if (ch & 0x80) {
  1377.                 /* Insert With Name Reference */

  1379.                 st->state = sw_inr;

  1381.             } else if (ch & 0x40) {
  1382.                 /* Insert With Literal Name */

  1384.                 st->state = sw_iln;

  1386.             } else if (ch & 0x20) {
  1387.                 /* Set Dynamic Table Capacity */

  1389.                 st->state = sw_capacity;

  1391.             } else {
  1392.                 /* Duplicate */

  1394.                 st->state = sw_duplicate;
  1395.             }
  1396.         }

  1398.         switch (st->state) {

  1400.         case sw_inr:

  1402.             rc = ngx_http_v3_parse_field_inr(c, &st->field, b);
  1403.             if (rc != NGX_DONE) {
  1404.                 return rc;
  1405.             }

  1407.             st->state = sw_start;
  1408.             break;

  1410.         case sw_iln:

  1412.             rc = ngx_http_v3_parse_field_iln(c, &st->field, b);
  1413.             if (rc != NGX_DONE) {
  1414.                 return rc;
  1415.             }

  1417.             st->state = sw_start;
  1418.             break;

  1420.         case sw_capacity:

  1422.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, b);
  1423.             if (rc != NGX_DONE) {
  1424.                 return rc;
  1425.             }

  1427.             rc = ngx_http_v3_set_capacity(c, st->pint.value);
  1428.             if (rc != NGX_OK) {
  1429.                 return rc;
  1430.             }

  1432.             st->state = sw_start;
  1433.             break;

  1435.         default: /* sw_duplicate */

  1437.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, b);
  1438.             if (rc != NGX_DONE) {
  1439.                 return rc;
  1440.             }

  1442.             rc = ngx_http_v3_duplicate(c, st->pint.value);
  1443.             if (rc != NGX_OK) {
  1444.                 return rc;
  1445.             }

  1447.             st->state = sw_start;
  1448.             break;
  1449.         }
  1450.     }
  1451. }


  1454. static ngx_int_t
  1455. ‌ngx_http_v3_parse_field_inr(ngx_connection_t *c,
  1456.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  1457. {
  1458.     u_char     ch;
  1459.     ngx_int_t  rc;
  1460. ‌    enum {
  1461.         sw_start = 0,
  1462.         sw_name_index,
  1463.         sw_value_len,
  1464.         sw_read_value_len,
  1465.         sw_value
  1466.     };

  1468.     for ( ;; ) {

  1470.         switch (st->state) {

  1472.         case sw_start:

  1474.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1475.                            "http3 parse field inr");

  1477.             if (b->pos == b->last) {
  1478.                 return NGX_AGAIN;
  1479.             }

  1481.             ch = *b->pos;

  1483.             st->dynamic = (ch & 0x40) ? 0 : 1;
  1484.             st->state = sw_name_index;

  1486.             /* fall through */

  1488.         case sw_name_index:

  1490.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  1491.             if (rc != NGX_DONE) {
  1492.                 return rc;
  1493.             }

  1495.             st->index = st->pint.value;
  1496.             st->state = sw_value_len;
  1497.             break;

  1499.         case sw_value_len:

  1501.             if (b->pos == b->last) {
  1502.                 return NGX_AGAIN;
  1503.             }

  1505.             ch = *b->pos;

  1507.             st->literal.huffman = (ch & 0x80) ? 1 : 0;
  1508.             st->state = sw_read_value_len;

  1510.             /* fall through */

  1512.         case sw_read_value_len:

  1514.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1515.             if (rc != NGX_DONE) {
  1516.                 return rc;
  1517.             }

  1519.             st->literal.length = st->pint.value;
  1520.             if (st->literal.length == 0) {
  1521.                 st->value.len = 0;
  1522.                 goto done;
  1523.             }

  1525.             st->state = sw_value;
  1526.             break;

  1528.         case sw_value:

  1530.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1531.             if (rc != NGX_DONE) {
  1532.                 return rc;
  1533.             }

  1535.             st->value = st->literal.value;
  1536.             goto done;
  1537.         }
  1538.     }

  1540. done:

  1542.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1543.                    "http3 parse field inr done %s[%ui] \"%V\"",
  1544.                    st->dynamic ? "dynamic" : "static",
  1545.                    st->index, &st->value);

  1547.     rc = ngx_http_v3_ref_insert(c, st->dynamic, st->index, &st->value);
  1548.     if (rc != NGX_OK) {
  1549.         return rc;
  1550.     }

  1552.     st->state = sw_start;
  1553.     return NGX_DONE;
  1554. }


  1557. static ngx_int_t
  1558. ‌ngx_http_v3_parse_field_iln(ngx_connection_t *c,
  1559.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  1560. {
  1561.     u_char     ch;
  1562.     ngx_int_t  rc;
  1563. ‌    enum {
  1564.         sw_start = 0,
  1565.         sw_name_len,
  1566.         sw_name,
  1567.         sw_value_len,
  1568.         sw_read_value_len,
  1569.         sw_value
  1570.     };

  1572.     for ( ;; ) {

  1574.         switch (st->state) {

  1576.         case sw_start:

  1578.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1579.                            "http3 parse field iln");

  1581.             if (b->pos == b->last) {
  1582.                 return NGX_AGAIN;
  1583.             }

  1585.             ch = *b->pos;

  1587.             st->literal.huffman = (ch & 0x20) ? 1 : 0;
  1588.             st->state = sw_name_len;

  1590.             /* fall through */

  1592.         case sw_name_len:

  1594.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, b);
  1595.             if (rc != NGX_DONE) {
  1596.                 return rc;
  1597.             }

  1599.             st->literal.length = st->pint.value;
  1600.             if (st->literal.length == 0) {
  1601.                 return NGX_ERROR;
  1602.             }

  1604.             st->state = sw_name;
  1605.             break;

  1607.         case sw_name:

  1609.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1610.             if (rc != NGX_DONE) {
  1611.                 return rc;
  1612.             }

  1614.             st->name = st->literal.value;
  1615.             st->state = sw_value_len;
  1616.             break;

  1618.         case sw_value_len:

  1620.             if (b->pos == b->last) {
  1621.                 return NGX_AGAIN;
  1622.             }

  1624.             ch = *b->pos;

  1626.             st->literal.huffman = (ch & 0x80) ? 1 : 0;
  1627.             st->state = sw_read_value_len;

  1629.             /* fall through */

  1631.         case sw_read_value_len:

  1633.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1634.             if (rc != NGX_DONE) {
  1635.                 return rc;
  1636.             }

  1638.             st->literal.length = st->pint.value;
  1639.             if (st->literal.length == 0) {
  1640.                 st->value.len = 0;
  1641.                 goto done;
  1642.             }

  1644.             st->state = sw_value;
  1645.             break;

  1647.         case sw_value:

  1649.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1650.             if (rc != NGX_DONE) {
  1651.                 return rc;
  1652.             }

  1654.             st->value = st->literal.value;
  1655.             goto done;
  1656.         }
  1657.     }

  1659. done:

  1661.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1662.                    "http3 parse field iln done \"%V\":\"%V\"",
  1663.                    &st->name, &st->value);

  1665.     rc = ngx_http_v3_insert(c, &st->name, &st->value);
  1666.     if (rc != NGX_OK) {
  1667.         return rc;
  1668.     }

  1670.     st->state = sw_start;
  1671.     return NGX_DONE;
  1672. }


  1675. static ngx_int_t
  1676. ‌ngx_http_v3_parse_decoder(ngx_connection_t *c, ngx_http_v3_parse_decoder_t *st,
  1677.     ngx_buf_t *b)
  1678. {
  1679.     u_char     ch;
  1680.     ngx_int_t  rc;
  1681. ‌    enum {
  1682.         sw_start = 0,
  1683.         sw_ack_section,
  1684.         sw_cancel_stream,
  1685.         sw_inc_insert_count
  1686.     };

  1688.     for ( ;; ) {

  1690.         if (st->state == sw_start) {

  1692.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1693.                            "http3 parse decoder instruction");

  1695.             if (b->pos == b->last) {
  1696.                 return NGX_AGAIN;
  1697.             }

  1699.             ch = *b->pos;

  1701.             if (ch & 0x80) {
  1702.                 /* Section Acknowledgment */

  1704.                 st->state = sw_ack_section;

  1706.             } else if (ch & 0x40) {
  1707.                 /*  Stream Cancellation */

  1709.                 st->state = sw_cancel_stream;

  1711.             }  else {
  1712.                 /*  Insert Count Increment */

  1714.                 st->state = sw_inc_insert_count;
  1715.             }
  1716.         }

  1718.         switch (st->state) {

  1720.         case sw_ack_section:

  1722.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1723.             if (rc != NGX_DONE) {
  1724.                 return rc;
  1725.             }

  1727.             rc = ngx_http_v3_ack_section(c, st->pint.value);
  1728.             if (rc != NGX_OK) {
  1729.                 return rc;
  1730.             }

  1732.             st->state = sw_start;
  1733.             break;

  1735.         case sw_cancel_stream:

  1737.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  1738.             if (rc != NGX_DONE) {
  1739.                 return rc;
  1740.             }

  1742.             rc = ngx_http_v3_cancel_stream(c, st->pint.value);
  1743.             if (rc != NGX_OK) {
  1744.                 return rc;
  1745.             }

  1747.             st->state = sw_start;
  1748.             break;

  1750.         case sw_inc_insert_count:

  1752.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  1753.             if (rc != NGX_DONE) {
  1754.                 return rc;
  1755.             }

  1757.             rc = ngx_http_v3_inc_insert_count(c, st->pint.value);
  1758.             if (rc != NGX_OK) {
  1759.                 return rc;
  1760.             }

  1762.             st->state = sw_start;
  1763.             break;
  1764.         }
  1765.     }
  1766. }


  1769. ngx_int_t
  1770. ‌ngx_http_v3_parse_data(ngx_connection_t *c, ngx_http_v3_parse_data_t *st,
  1771.     ngx_buf_t *b)
  1772. {
  1773.     ngx_int_t  rc;
  1774. ‌    enum {
  1775.         sw_start = 0,
  1776.         sw_type,
  1777.         sw_length,
  1778.         sw_skip
  1779.     };

  1781.     for ( ;; ) {

  1783.         switch (st->state) {

  1785.         case sw_start:

  1787.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse data");

  1789.             st->state = sw_type;

  1791.             /* fall through */

  1793.         case sw_type:

  1795.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1796.             if (rc != NGX_DONE) {
  1797.                 return rc;
  1798.             }

  1800.             st->type = st->vlint.value;

  1802.             if (st->type == NGX_HTTP_V3_FRAME_HEADERS) {
  1803.                 /* trailers */
  1804.                 goto done;
  1805.             }

  1807.             if (ngx_http_v3_is_v2_frame(st->type)
  1808.                 || st->type == NGX_HTTP_V3_FRAME_GOAWAY
  1809.                 || st->type == NGX_HTTP_V3_FRAME_SETTINGS
  1810.                 || st->type == NGX_HTTP_V3_FRAME_MAX_PUSH_ID
  1811.                 || st->type == NGX_HTTP_V3_FRAME_CANCEL_PUSH
  1812.                 || st->type == NGX_HTTP_V3_FRAME_PUSH_PROMISE)
  1813.             {
  1814.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  1815.             }

  1817.             st->state = sw_length;
  1818.             break;

  1820.         case sw_length:

  1822.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1823.             if (rc != NGX_DONE) {
  1824.                 return rc;
  1825.             }

  1827.             st->length = st->vlint.value;

  1829.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1830.                            "http3 parse data type:%ui, len:%ui",
  1831.                            st->type, st->length);

  1833.             if (st->type != NGX_HTTP_V3_FRAME_DATA && st->length > 0) {
  1834.                 st->state = sw_skip;
  1835.                 break;
  1836.             }

  1838.             st->state = sw_type;
  1839.             return NGX_OK;

  1841.         case sw_skip:

  1843.             rc = ngx_http_v3_parse_skip(b, &st->length);
  1844.             if (rc != NGX_DONE) {
  1845.                 return rc;
  1846.             }

  1848.             st->state = sw_type;
  1849.             break;
  1850.         }
  1851.     }

  1853. done:

  1855.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse data done");

  1857.     st->state = sw_start;
  1858.     return NGX_DONE;
  1859. }


  1862. ngx_int_t
  1863. ‌ngx_http_v3_parse_uni(ngx_connection_t *c, ngx_http_v3_parse_uni_t *st,
  1864.     ngx_buf_t *b)
  1865. {
  1866.     ngx_int_t  rc;
  1867. ‌    enum {
  1868.         sw_start = 0,
  1869.         sw_type,
  1870.         sw_control,
  1871.         sw_encoder,
  1872.         sw_decoder,
  1873.         sw_unknown
  1874.     };

  1876.     for ( ;; ) {

  1878.         switch (st->state) {
  1879.         case sw_start:

  1881.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse uni");

  1883.             st->state = sw_type;

  1885.             /* fall through */

  1887.         case sw_type:

  1889.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1890.             if (rc != NGX_DONE) {
  1891.                 return rc;
  1892.             }

  1894.             rc = ngx_http_v3_register_uni_stream(c, st->vlint.value);
  1895.             if (rc != NGX_OK) {
  1896.                 return rc;
  1897.             }

  1899.             switch (st->vlint.value) {
  1900.             case NGX_HTTP_V3_STREAM_CONTROL:
  1901.                 st->state = sw_control;
  1902.                 break;

  1904.             case NGX_HTTP_V3_STREAM_ENCODER:
  1905.                 st->state = sw_encoder;
  1906.                 break;

  1908.             case NGX_HTTP_V3_STREAM_DECODER:
  1909.                 st->state = sw_decoder;
  1910.                 break;

  1912.             default:
  1913.                 st->state = sw_unknown;
  1914.             }

  1916.             break;

  1918.         case sw_control:

  1920.             return ngx_http_v3_parse_control(c, &st->u.control, b);

  1922.         case sw_encoder:

  1924.             return ngx_http_v3_parse_encoder(c, &st->u.encoder, b);

  1926.         case sw_decoder:

  1928.             return ngx_http_v3_parse_decoder(c, &st->u.decoder, b);

  1930.         case sw_unknown:

  1932.             b->pos = b->last;
  1933.             return NGX_AGAIN;
  1934.         }
  1935.     }
  1936. }

One Level Up Top Level