One Level Up Top Level

src/http/v3/ngx_http_v3_parse.c - nginx

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.                 if (n > NGX_MAX_INT_T_VALUE / 8) {
  627.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  628.                                   "client sent too large field line");
  629.                     return NGX_HTTP_V3_ERR_EXCESSIVE_LOAD;
  630.                 }

  632.                 n = n * 8 / 5;
  633.                 st->huffstate = 0;
  634.             }

  636.             if (st->buf) {
  637.                 if ((size_t) (st->buf->end - st->buf->last) < n + 1) {
  638.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  639.                                   "not enough dynamic table capacity");

  641.                     st->last = NULL;
  642.                     return NGX_ERROR;
  643.                 }

  645.                 st->last = st->buf->last;
  646.                 st->buf->last += n + 1;

  648.             } else {
  649.                 st->last = ngx_pnalloc(c->pool, n + 1);
  650.                 if (st->last == NULL) {
  651.                     return NGX_ERROR;
  652.                 }
  653.             }

  655.             st->value.data = st->last;
  656.             st->state = sw_value;

  658.             /* fall through */

  660.         case sw_value:

  662.             if (b->pos == b->last) {
  663.                 return NGX_AGAIN;
  664.             }

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

  668.             if (st->huffman) {
  669.                 if (ngx_http_huff_decode(&st->huffstate, &ch, 1, &st->last,
  670.                                          st->length == 1, c->log)
  671.                     != NGX_OK)
  672.                 {
  673.                     ngx_log_error(NGX_LOG_INFO, c->log, 0,
  674.                                   "client sent invalid encoded field line");
  675.                     return NGX_ERROR;
  676.                 }

  678.             } else {
  679.                 *st->last++ = ch;
  680.             }

  682.             if (--st->length) {
  683.                 break;
  684.             }

  686.             st->value.len = st->last - st->value.data;
  687.             *st->last = '\0';
  688.             goto done;
  689.         }
  690.     }

  692. done:

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

  697.     st->state = sw_start;
  698.     return NGX_DONE;
  699. }


  702. static ngx_int_t
  703. ‌ngx_http_v3_parse_field_ri(ngx_connection_t *c, ngx_http_v3_parse_field_t *st,
  704.     ngx_buf_t *b)
  705. {
  706.     u_char     ch;
  707.     ngx_int_t  rc;
  708. ‌    enum {
  709.         sw_start = 0,
  710.         sw_index
  711.     };

  713.     for ( ;; ) {

  715.         switch (st->state) {

  717.         case sw_start:

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

  722.             if (b->pos == b->last) {
  723.                 return NGX_AGAIN;
  724.             }

  726.             ch = *b->pos;

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

  731.             /* fall through */

  733.         case sw_index:

  735.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  736.             if (rc != NGX_DONE) {
  737.                 return rc;
  738.             }

  740.             st->index = st->pint.value;
  741.             goto done;
  742.         }
  743.     }

  745. done:

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

  751.     if (st->dynamic) {
  752.         st->index = st->base - st->index - 1;
  753.     }

  755.     rc = ngx_http_v3_parse_lookup(c, st->dynamic, st->index, &st->name,
  756.                                   &st->value);
  757.     if (rc != NGX_OK) {
  758.         return rc;
  759.     }

  761.     st->state = sw_start;
  762.     return NGX_DONE;
  763. }


  766. static ngx_int_t
  767. ‌ngx_http_v3_parse_field_lri(ngx_connection_t *c,
  768.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  769. {
  770.     u_char     ch;
  771.     ngx_int_t  rc;
  772. ‌    enum {
  773.         sw_start = 0,
  774.         sw_index,
  775.         sw_value_len,
  776.         sw_read_value_len,
  777.         sw_value
  778.     };

  780.     for ( ;; ) {

  782.         switch (st->state) {

  784.         case sw_start:

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

  789.             if (b->pos == b->last) {
  790.                 return NGX_AGAIN;
  791.             }

  793.             ch = *b->pos;

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

  798.             /* fall through */

  800.         case sw_index:

  802.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 4, b);
  803.             if (rc != NGX_DONE) {
  804.                 return rc;
  805.             }

  807.             st->index = st->pint.value;
  808.             st->state = sw_value_len;
  809.             break;

  811.         case sw_value_len:

  813.             if (b->pos == b->last) {
  814.                 return NGX_AGAIN;
  815.             }

  817.             ch = *b->pos;

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

  822.             /* fall through */

  824.         case sw_read_value_len:

  826.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  827.             if (rc != NGX_DONE) {
  828.                 return rc;
  829.             }

  831.             st->literal.length = st->pint.value;
  832.             if (st->literal.length == 0) {
  833.                 st->value.data = (u_char *) "";
  834.                 goto done;
  835.             }

  837.             st->state = sw_value;
  838.             break;

  840.         case sw_value:

  842.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  843.             if (rc != NGX_DONE) {
  844.                 return rc;
  845.             }

  847.             st->value = st->literal.value;
  848.             goto done;
  849.         }
  850.     }

  852. done:

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

  859.     if (st->dynamic) {
  860.         st->index = st->base - st->index - 1;
  861.     }

  863.     rc = ngx_http_v3_parse_lookup(c, st->dynamic, st->index, &st->name, NULL);
  864.     if (rc != NGX_OK) {
  865.         return rc;
  866.     }

  868.     st->state = sw_start;
  869.     return NGX_DONE;
  870. }


  873. static ngx_int_t
  874. ‌ngx_http_v3_parse_field_l(ngx_connection_t *c,
  875.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  876. {
  877.     u_char     ch;
  878.     ngx_int_t  rc;
  879. ‌    enum {
  880.         sw_start = 0,
  881.         sw_name_len,
  882.         sw_name,
  883.         sw_value_len,
  884.         sw_read_value_len,
  885.         sw_value
  886.     };

  888.     for ( ;; ) {

  890.         switch (st->state) {

  892.         case sw_start:

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

  897.             if (b->pos == b->last) {
  898.                 return NGX_AGAIN;
  899.             }

  901.             ch = *b->pos;

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

  906.             /* fall through */

  908.         case sw_name_len:

  910.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 3, b);
  911.             if (rc != NGX_DONE) {
  912.                 return rc;
  913.             }

  915.             st->literal.length = st->pint.value;
  916.             if (st->literal.length == 0) {
  917.                 return NGX_ERROR;
  918.             }

  920.             st->state = sw_name;
  921.             break;

  923.         case sw_name:

  925.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  926.             if (rc != NGX_DONE) {
  927.                 return rc;
  928.             }

  930.             st->name = st->literal.value;
  931.             st->state = sw_value_len;
  932.             break;

  934.         case sw_value_len:

  936.             if (b->pos == b->last) {
  937.                 return NGX_AGAIN;
  938.             }

  940.             ch = *b->pos;

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

  945.             /* fall through */

  947.         case sw_read_value_len:

  949.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  950.             if (rc != NGX_DONE) {
  951.                 return rc;
  952.             }

  954.             st->literal.length = st->pint.value;
  955.             if (st->literal.length == 0) {
  956.                 st->value.data = (u_char *) "";
  957.                 goto done;
  958.             }

  960.             st->state = sw_value;
  961.             break;

  963.         case sw_value:

  965.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  966.             if (rc != NGX_DONE) {
  967.                 return rc;
  968.             }

  970.             st->value = st->literal.value;
  971.             goto done;
  972.         }
  973.     }

  975. done:

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

  981.     st->state = sw_start;
  982.     return NGX_DONE;
  983. }


  986. static ngx_int_t
  987. ‌ngx_http_v3_parse_field_pbi(ngx_connection_t *c,
  988.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  989. {
  990.     ngx_int_t  rc;
  991. ‌    enum {
  992.         sw_start = 0,
  993.         sw_index
  994.     };

  996.     for ( ;; ) {

  998.         switch (st->state) {

  1000.         case sw_start:

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

  1005.             st->state = sw_index;

  1007.             /* fall through */

  1009.         case sw_index:

  1011.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 4, b);
  1012.             if (rc != NGX_DONE) {
  1013.                 return rc;
  1014.             }

  1016.             st->index = st->pint.value;
  1017.             goto done;
  1018.         }
  1019.     }

  1021. done:

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

  1026.     rc = ngx_http_v3_parse_lookup(c, 1, st->base + st->index, &st->name,
  1027.                                   &st->value);
  1028.     if (rc != NGX_OK) {
  1029.         return rc;
  1030.     }

  1032.     st->state = sw_start;
  1033.     return NGX_DONE;
  1034. }


  1037. static ngx_int_t
  1038. ‌ngx_http_v3_parse_field_lpbi(ngx_connection_t *c,
  1039.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  1040. {
  1041.     u_char     ch;
  1042.     ngx_int_t  rc;
  1043. ‌    enum {
  1044.         sw_start = 0,
  1045.         sw_index,
  1046.         sw_value_len,
  1047.         sw_read_value_len,
  1048.         sw_value
  1049.     };

  1051.     for ( ;; ) {

  1053.         switch (st->state) {

  1055.         case sw_start:

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

  1060.             st->state = sw_index;

  1062.             /* fall through */

  1064.         case sw_index:

  1066.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 3, b);
  1067.             if (rc != NGX_DONE) {
  1068.                 return rc;
  1069.             }

  1071.             st->index = st->pint.value;
  1072.             st->state = sw_value_len;
  1073.             break;

  1075.         case sw_value_len:

  1077.             if (b->pos == b->last) {
  1078.                 return NGX_AGAIN;
  1079.             }

  1081.             ch = *b->pos;

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

  1086.             /* fall through */

  1088.         case sw_read_value_len:

  1090.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1091.             if (rc != NGX_DONE) {
  1092.                 return rc;
  1093.             }

  1095.             st->literal.length = st->pint.value;
  1096.             if (st->literal.length == 0) {
  1097.                 st->value.data = (u_char *) "";
  1098.                 goto done;
  1099.             }

  1101.             st->state = sw_value;
  1102.             break;

  1104.         case sw_value:

  1106.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1107.             if (rc != NGX_DONE) {
  1108.                 return rc;
  1109.             }

  1111.             st->value = st->literal.value;
  1112.             goto done;
  1113.         }
  1114.     }

  1116. done:

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

  1122.     rc = ngx_http_v3_parse_lookup(c, 1, st->base + st->index, &st->name, NULL);
  1123.     if (rc != NGX_OK) {
  1124.         return rc;
  1125.     }

  1127.     st->state = sw_start;
  1128.     return NGX_DONE;
  1129. }


  1132. static ngx_int_t
  1133. ‌ngx_http_v3_parse_lookup(ngx_connection_t *c, ngx_uint_t dynamic,
  1134.     ngx_uint_t index, ngx_str_t *name, ngx_str_t *value)
  1135. {
  1136.     u_char  *p;

  1138.     if (!dynamic) {
  1139.         if (ngx_http_v3_lookup_static(c, index, name, value) != NGX_OK) {
  1140.             return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  1141.         }

  1143.         return NGX_OK;
  1144.     }

  1146.     if (ngx_http_v3_lookup(c, index, name, value) != NGX_OK) {
  1147.         return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED;
  1148.     }

  1150.     if (name) {
  1151.         p = ngx_pnalloc(c->pool, name->len + 1);
  1152.         if (p == NULL) {
  1153.             return NGX_ERROR;
  1154.         }

  1156.         ngx_memcpy(p, name->data, name->len);
  1157.         p[name->len] = '\0';
  1158.         name->data = p;
  1159.     }

  1161.     if (value) {
  1162.         p = ngx_pnalloc(c->pool, value->len + 1);
  1163.         if (p == NULL) {
  1164.             return NGX_ERROR;
  1165.         }

  1167.         ngx_memcpy(p, value->data, value->len);
  1168.         p[value->len] = '\0';
  1169.         value->data = p;
  1170.     }

  1172.     return NGX_OK;
  1173. }


  1176. static ngx_int_t
  1177. ‌ngx_http_v3_parse_control(ngx_connection_t *c, ngx_http_v3_parse_control_t *st,
  1178.     ngx_buf_t *b)
  1179. {
  1180.     ngx_buf_t  loc;
  1181.     ngx_int_t  rc;
  1182. ‌    enum {
  1183.         sw_start = 0,
  1184.         sw_first_type,
  1185.         sw_type,
  1186.         sw_length,
  1187.         sw_settings,
  1188.         sw_skip
  1189.     };

  1191.     for ( ;; ) {

  1193.         switch (st->state) {

  1195.         case sw_start:

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

  1200.             st->state = sw_first_type;

  1202.             /* fall through */

  1204.         case sw_first_type:
  1205.         case sw_type:

  1207.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1208.             if (rc != NGX_DONE) {
  1209.                 return rc;
  1210.             }

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

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

  1217.             if (st->state == sw_first_type
  1218.                 && st->type != NGX_HTTP_V3_FRAME_SETTINGS)
  1219.             {
  1220.                 return NGX_HTTP_V3_ERR_MISSING_SETTINGS;
  1221.             }

  1223.             if (st->state != sw_first_type
  1224.                 && st->type == NGX_HTTP_V3_FRAME_SETTINGS)
  1225.             {
  1226.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  1227.             }

  1229.             if (ngx_http_v3_is_v2_frame(st->type)
  1230.                 || st->type == NGX_HTTP_V3_FRAME_DATA
  1231.                 || st->type == NGX_HTTP_V3_FRAME_HEADERS
  1232.                 || st->type == NGX_HTTP_V3_FRAME_PUSH_PROMISE)
  1233.             {
  1234.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  1235.             }

  1237.             if (st->type == NGX_HTTP_V3_FRAME_CANCEL_PUSH) {
  1238.                 return NGX_HTTP_V3_ERR_ID_ERROR;
  1239.             }

  1241.             st->state = sw_length;
  1242.             break;

  1244.         case sw_length:

  1246.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1247.             if (rc != NGX_DONE) {
  1248.                 return rc;
  1249.             }

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

  1254.             st->length = st->vlint.value;
  1255.             if (st->length == 0) {
  1256.                 st->state = sw_type;
  1257.                 break;
  1258.             }

  1260.             switch (st->type) {

  1262.             case NGX_HTTP_V3_FRAME_SETTINGS:
  1263.                 st->state = sw_settings;
  1264.                 break;

  1266.             default:
  1267.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1268.                                "http3 parse skip unknown frame");
  1269.                 st->state = sw_skip;
  1270.             }

  1272.             break;

  1274.         case sw_settings:

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

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

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

  1282.             if (st->length == 0 && rc == NGX_AGAIN) {
  1283.                 return NGX_HTTP_V3_ERR_SETTINGS_ERROR;
  1284.             }

  1286.             if (rc != NGX_DONE) {
  1287.                 return rc;
  1288.             }

  1290.             if (st->length == 0) {
  1291.                 st->state = sw_type;
  1292.             }

  1294.             break;

  1296.         case sw_skip:

  1298.             rc = ngx_http_v3_parse_skip(b, &st->length);
  1299.             if (rc != NGX_DONE) {
  1300.                 return rc;
  1301.             }

  1303.             st->state = sw_type;
  1304.             break;
  1305.         }
  1306.     }
  1307. }


  1310. static ngx_int_t
  1311. ‌ngx_http_v3_parse_settings(ngx_connection_t *c,
  1312.     ngx_http_v3_parse_settings_t *st, ngx_buf_t *b)
  1313. {
  1314.     ngx_int_t  rc;
  1315. ‌    enum {
  1316.         sw_start = 0,
  1317.         sw_id,
  1318.         sw_value
  1319.     };

  1321.     for ( ;; ) {

  1323.         switch (st->state) {

  1325.         case sw_start:

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

  1330.             st->state = sw_id;

  1332.             /* fall through */

  1334.         case sw_id:

  1336.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1337.             if (rc != NGX_DONE) {
  1338.                 return rc;
  1339.             }

  1341.             st->id = st->vlint.value;
  1342.             st->state = sw_value;
  1343.             break;

  1345.         case sw_value:

  1347.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1348.             if (rc != NGX_DONE) {
  1349.                 return rc;
  1350.             }

  1352.             if (ngx_http_v3_set_param(c, st->id, st->vlint.value) != NGX_OK) {
  1353.                 return NGX_HTTP_V3_ERR_SETTINGS_ERROR;
  1354.             }

  1356.             goto done;
  1357.         }
  1358.     }

  1360. done:

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

  1364.     st->state = sw_start;
  1365.     return NGX_DONE;
  1366. }


  1369. static ngx_int_t
  1370. ‌ngx_http_v3_parse_encoder(ngx_connection_t *c, ngx_http_v3_parse_encoder_t *st,
  1371.     ngx_buf_t *b)
  1372. {
  1373.     u_char     ch;
  1374.     ngx_int_t  rc;
  1375. ‌    enum {
  1376.         sw_start = 0,
  1377.         sw_inr,
  1378.         sw_iln,
  1379.         sw_capacity,
  1380.         sw_duplicate
  1381.     };

  1383.     for ( ;; ) {

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

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

  1390.             if (b->pos == b->last) {
  1391.                 return NGX_AGAIN;
  1392.             }

  1394.             ch = *b->pos;

  1396.             if (ch & 0x80) {
  1397.                 /* Insert With Name Reference */

  1399.                 st->state = sw_inr;

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

  1404.                 st->state = sw_iln;

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

  1409.                 st->state = sw_capacity;

  1411.             } else {
  1412.                 /* Duplicate */

  1414.                 st->state = sw_duplicate;
  1415.             }
  1416.         }

  1418.         switch (st->state) {

  1420.         case sw_inr:

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

  1427.             st->state = sw_start;
  1428.             break;

  1430.         case sw_iln:

  1432.             rc = ngx_http_v3_parse_field_iln(c, &st->field, b);
  1433.             if (rc != NGX_DONE) {
  1434.                 return rc;
  1435.             }

  1437.             st->state = sw_start;
  1438.             break;

  1440.         case sw_capacity:

  1442.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, b);
  1443.             if (rc != NGX_DONE) {
  1444.                 return rc;
  1445.             }

  1447.             rc = ngx_http_v3_set_capacity(c, st->pint.value);
  1448.             if (rc != NGX_OK) {
  1449.                 return rc;
  1450.             }

  1452.             st->state = sw_start;
  1453.             break;

  1455.         default: /* sw_duplicate */

  1457.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, b);
  1458.             if (rc != NGX_DONE) {
  1459.                 return rc;
  1460.             }

  1462.             rc = ngx_http_v3_duplicate(c, st->pint.value);
  1463.             if (rc != NGX_OK) {
  1464.                 return rc;
  1465.             }

  1467.             st->state = sw_start;
  1468.             break;
  1469.         }
  1470.     }
  1471. }


  1474. static ngx_int_t
  1475. ‌ngx_http_v3_parse_field_inr(ngx_connection_t *c,
  1476.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  1477. {
  1478.     u_char     ch;
  1479.     ngx_int_t  rc;
  1480. ‌    enum {
  1481.         sw_start = 0,
  1482.         sw_name_index,
  1483.         sw_value_len,
  1484.         sw_read_value_len,
  1485.         sw_value
  1486.     };

  1488.     for ( ;; ) {

  1490.         switch (st->state) {

  1492.         case sw_start:

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

  1497.             if (b->pos == b->last) {
  1498.                 return NGX_AGAIN;
  1499.             }

  1501.             ch = *b->pos;

  1503.             st->literal.buf = ngx_http_v3_get_insert_buffer(c);
  1504.             if (st->literal.buf == NULL) {
  1505.                 return NGX_ERROR;
  1506.             }

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

  1511.             /* fall through */

  1513.         case sw_name_index:

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

  1520.             st->index = st->pint.value;
  1521.             st->state = sw_value_len;
  1522.             break;

  1524.         case sw_value_len:

  1526.             if (b->pos == b->last) {
  1527.                 return NGX_AGAIN;
  1528.             }

  1530.             ch = *b->pos;

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

  1535.             /* fall through */

  1537.         case sw_read_value_len:

  1539.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1540.             if (rc != NGX_DONE) {
  1541.                 return rc;
  1542.             }

  1544.             st->literal.length = st->pint.value;
  1545.             if (st->literal.length == 0) {
  1546.                 st->value.len = 0;
  1547.                 goto done;
  1548.             }

  1550.             st->state = sw_value;
  1551.             break;

  1553.         case sw_value:

  1555.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1556.             if (rc != NGX_DONE) {
  1557.                 return rc;
  1558.             }

  1560.             st->value = st->literal.value;
  1561.             goto done;
  1562.         }
  1563.     }

  1565. done:

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

  1572.     rc = ngx_http_v3_ref_insert(c, st->dynamic, st->index, &st->value);
  1573.     if (rc != NGX_OK) {
  1574.         return rc;
  1575.     }

  1577.     st->state = sw_start;
  1578.     return NGX_DONE;
  1579. }


  1582. static ngx_int_t
  1583. ‌ngx_http_v3_parse_field_iln(ngx_connection_t *c,
  1584.     ngx_http_v3_parse_field_t *st, ngx_buf_t *b)
  1585. {
  1586.     u_char     ch;
  1587.     ngx_int_t  rc;
  1588. ‌    enum {
  1589.         sw_start = 0,
  1590.         sw_name_len,
  1591.         sw_name,
  1592.         sw_value_len,
  1593.         sw_read_value_len,
  1594.         sw_value
  1595.     };

  1597.     for ( ;; ) {

  1599.         switch (st->state) {

  1601.         case sw_start:

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

  1606.             if (b->pos == b->last) {
  1607.                 return NGX_AGAIN;
  1608.             }

  1610.             ch = *b->pos;

  1612.             st->literal.buf = ngx_http_v3_get_insert_buffer(c);
  1613.             if (st->literal.buf == NULL) {
  1614.                 return NGX_ERROR;
  1615.             }

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

  1620.             /* fall through */

  1622.         case sw_name_len:

  1624.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, b);
  1625.             if (rc != NGX_DONE) {
  1626.                 return rc;
  1627.             }

  1629.             st->literal.length = st->pint.value;
  1630.             if (st->literal.length == 0) {
  1631.                 return NGX_ERROR;
  1632.             }

  1634.             st->state = sw_name;
  1635.             break;

  1637.         case sw_name:

  1639.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1640.             if (rc != NGX_DONE) {
  1641.                 return rc;
  1642.             }

  1644.             st->name = st->literal.value;
  1645.             st->state = sw_value_len;
  1646.             break;

  1648.         case sw_value_len:

  1650.             if (b->pos == b->last) {
  1651.                 return NGX_AGAIN;
  1652.             }

  1654.             ch = *b->pos;

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

  1659.             /* fall through */

  1661.         case sw_read_value_len:

  1663.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, b);
  1664.             if (rc != NGX_DONE) {
  1665.                 return rc;
  1666.             }

  1668.             st->literal.length = st->pint.value;
  1669.             if (st->literal.length == 0) {
  1670.                 st->value.len = 0;
  1671.                 goto done;
  1672.             }

  1674.             st->state = sw_value;
  1675.             break;

  1677.         case sw_value:

  1679.             rc = ngx_http_v3_parse_literal(c, &st->literal, b);
  1680.             if (rc != NGX_DONE) {
  1681.                 return rc;
  1682.             }

  1684.             st->value = st->literal.value;
  1685.             goto done;
  1686.         }
  1687.     }

  1689. done:

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

  1695.     rc = ngx_http_v3_insert(c, &st->name, &st->value);
  1696.     if (rc != NGX_OK) {
  1697.         return rc;
  1698.     }

  1700.     st->state = sw_start;
  1701.     return NGX_DONE;
  1702. }


  1705. static ngx_int_t
  1706. ‌ngx_http_v3_parse_decoder(ngx_connection_t *c, ngx_http_v3_parse_decoder_t *st,
  1707.     ngx_buf_t *b)
  1708. {
  1709.     u_char     ch;
  1710.     ngx_int_t  rc;
  1711. ‌    enum {
  1712.         sw_start = 0,
  1713.         sw_ack_section,
  1714.         sw_cancel_stream,
  1715.         sw_inc_insert_count
  1716.     };

  1718.     for ( ;; ) {

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

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

  1725.             if (b->pos == b->last) {
  1726.                 return NGX_AGAIN;
  1727.             }

  1729.             ch = *b->pos;

  1731.             if (ch & 0x80) {
  1732.                 /* Section Acknowledgment */

  1734.                 st->state = sw_ack_section;

  1736.             } else if (ch & 0x40) {
  1737.                 /*  Stream Cancellation */

  1739.                 st->state = sw_cancel_stream;

  1741.             }  else {
  1742.                 /*  Insert Count Increment */

  1744.                 st->state = sw_inc_insert_count;
  1745.             }
  1746.         }

  1748.         switch (st->state) {

  1750.         case sw_ack_section:

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

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

  1762.             st->state = sw_start;
  1763.             break;

  1765.         case sw_cancel_stream:

  1767.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  1768.             if (rc != NGX_DONE) {
  1769.                 return rc;
  1770.             }

  1772.             rc = ngx_http_v3_cancel_stream(c, st->pint.value);
  1773.             if (rc != NGX_OK) {
  1774.                 return rc;
  1775.             }

  1777.             st->state = sw_start;
  1778.             break;

  1780.         case sw_inc_insert_count:

  1782.             rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, b);
  1783.             if (rc != NGX_DONE) {
  1784.                 return rc;
  1785.             }

  1787.             rc = ngx_http_v3_inc_insert_count(c, st->pint.value);
  1788.             if (rc != NGX_OK) {
  1789.                 return rc;
  1790.             }

  1792.             st->state = sw_start;
  1793.             break;
  1794.         }
  1795.     }
  1796. }


  1799. ngx_int_t
  1800. ‌ngx_http_v3_parse_data(ngx_connection_t *c, ngx_http_v3_parse_data_t *st,
  1801.     ngx_buf_t *b)
  1802. {
  1803.     ngx_int_t  rc;
  1804. ‌    enum {
  1805.         sw_start = 0,
  1806.         sw_type,
  1807.         sw_length,
  1808.         sw_skip
  1809.     };

  1811.     for ( ;; ) {

  1813.         switch (st->state) {

  1815.         case sw_start:

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

  1819.             st->state = sw_type;

  1821.             /* fall through */

  1823.         case sw_type:

  1825.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1826.             if (rc != NGX_DONE) {
  1827.                 return rc;
  1828.             }

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

  1832.             if (st->type == NGX_HTTP_V3_FRAME_HEADERS) {
  1833.                 /* trailers */
  1834.                 goto done;
  1835.             }

  1837.             if (ngx_http_v3_is_v2_frame(st->type)
  1838.                 || st->type == NGX_HTTP_V3_FRAME_GOAWAY
  1839.                 || st->type == NGX_HTTP_V3_FRAME_SETTINGS
  1840.                 || st->type == NGX_HTTP_V3_FRAME_MAX_PUSH_ID
  1841.                 || st->type == NGX_HTTP_V3_FRAME_CANCEL_PUSH
  1842.                 || st->type == NGX_HTTP_V3_FRAME_PUSH_PROMISE)
  1843.             {
  1844.                 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED;
  1845.             }

  1847.             st->state = sw_length;
  1848.             break;

  1850.         case sw_length:

  1852.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1853.             if (rc != NGX_DONE) {
  1854.                 return rc;
  1855.             }

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

  1859.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1860.                            "http3 parse data type:%ui, len:%ui",
  1861.                            st->type, st->length);

  1863.             if (st->type != NGX_HTTP_V3_FRAME_DATA && st->length > 0) {
  1864.                 st->state = sw_skip;
  1865.                 break;
  1866.             }

  1868.             st->state = sw_type;
  1869.             return NGX_OK;

  1871.         case sw_skip:

  1873.             rc = ngx_http_v3_parse_skip(b, &st->length);
  1874.             if (rc != NGX_DONE) {
  1875.                 return rc;
  1876.             }

  1878.             st->state = sw_type;
  1879.             break;
  1880.         }
  1881.     }

  1883. done:

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

  1887.     st->state = sw_start;
  1888.     return NGX_DONE;
  1889. }


  1892. ngx_int_t
  1893. ‌ngx_http_v3_parse_uni(ngx_connection_t *c, ngx_http_v3_parse_uni_t *st,
  1894.     ngx_buf_t *b)
  1895. {
  1896.     ngx_int_t  rc;
  1897. ‌    enum {
  1898.         sw_start = 0,
  1899.         sw_type,
  1900.         sw_control,
  1901.         sw_encoder,
  1902.         sw_decoder,
  1903.         sw_unknown
  1904.     };

  1906.     for ( ;; ) {

  1908.         switch (st->state) {
  1909.         case sw_start:

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

  1913.             st->state = sw_type;

  1915.             /* fall through */

  1917.         case sw_type:

  1919.             rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, b);
  1920.             if (rc != NGX_DONE) {
  1921.                 return rc;
  1922.             }

  1924.             rc = ngx_http_v3_register_uni_stream(c, st->vlint.value);
  1925.             if (rc != NGX_OK) {
  1926.                 return rc;
  1927.             }

  1929.             switch (st->vlint.value) {
  1930.             case NGX_HTTP_V3_STREAM_CONTROL:
  1931.                 st->state = sw_control;
  1932.                 break;

  1934.             case NGX_HTTP_V3_STREAM_ENCODER:
  1935.                 st->state = sw_encoder;
  1936.                 break;

  1938.             case NGX_HTTP_V3_STREAM_DECODER:
  1939.                 st->state = sw_decoder;
  1940.                 break;

  1942.             default:
  1943.                 st->state = sw_unknown;
  1944.             }

  1946.             break;

  1948.         case sw_control:

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

  1952.         case sw_encoder:

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

  1956.         case sw_decoder:

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

  1960.         case sw_unknown:

  1962.             b->pos = b->last;
  1963.             return NGX_AGAIN;
  1964.         }
  1965.     }
  1966. }

One Level Up Top Level