Mercurial > hg > nginx
annotate src/http/v3/ngx_http_v3_parse.c @ 8772:345370fdd32d quic
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Previously it was parsed in ngx_http_v3_streams.c, while the streams were
parsed in ngx_http_v3_parse.c. Now all parsing is done in one file. This
simplifies parsing API and cleans up ngx_http_v3_streams.c.
| author | Roman Arutyunyan <arut@nginx.com> |
|---|---|
| date | Wed, 05 May 2021 15:00:17 +0300 |
| parents | 0981329169ea |
| children | 3509b9dcfb47 |
| rev | line source |
|---|---|
| 8226 | 1 |
| 2 /* | |
| 3 * Copyright (C) Roman Arutyunyan | |
| 4 * Copyright (C) Nginx, Inc. | |
| 5 */ | |
| 6 | |
| 7 | |
| 8 #include <ngx_config.h> | |
| 9 #include <ngx_core.h> | |
| 10 #include <ngx_http.h> | |
| 11 | |
| 12 | |
|
8550
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
13 #define ngx_http_v3_is_v2_frame(type) \ |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
14 ((type) == 0x02 || (type) == 0x06 || (type) == 0x08 || (type) == 0x09) |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
15 |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
16 |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
17 static ngx_int_t ngx_http_v3_parse_varlen_int(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
18 ngx_http_v3_parse_varlen_int_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
19 static ngx_int_t ngx_http_v3_parse_prefix_int(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
20 ngx_http_v3_parse_prefix_int_t *st, ngx_uint_t prefix, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
21 |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
22 static ngx_int_t ngx_http_v3_parse_header_block_prefix(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
23 ngx_http_v3_parse_header_block_prefix_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
24 static ngx_int_t ngx_http_v3_parse_header_rep(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
25 ngx_http_v3_parse_header_rep_t *st, ngx_uint_t base, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
26 static ngx_int_t ngx_http_v3_parse_literal(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
27 ngx_http_v3_parse_literal_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
28 static ngx_int_t ngx_http_v3_parse_header_ri(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
29 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
30 static ngx_int_t ngx_http_v3_parse_header_lri(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
31 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
32 static ngx_int_t ngx_http_v3_parse_header_l(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
33 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
34 static ngx_int_t ngx_http_v3_parse_header_pbi(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
35 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
36 static ngx_int_t ngx_http_v3_parse_header_lpbi(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
37 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
38 |
|
8772
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
39 static ngx_int_t ngx_http_v3_parse_control(ngx_connection_t *c, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
40 ngx_http_v3_parse_control_t *st, u_char ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
41 static ngx_int_t ngx_http_v3_parse_settings(ngx_connection_t *c, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
42 ngx_http_v3_parse_settings_t *st, u_char ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
43 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
44 static ngx_int_t ngx_http_v3_parse_encoder(ngx_connection_t *c, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
45 ngx_http_v3_parse_encoder_t *st, u_char ch); |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
46 static ngx_int_t ngx_http_v3_parse_header_inr(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
47 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
48 static ngx_int_t ngx_http_v3_parse_header_iwnr(ngx_connection_t *c, |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
49 ngx_http_v3_parse_header_t *st, u_char ch); |
|
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
50 |
|
8772
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
51 static ngx_int_t ngx_http_v3_parse_decoder(ngx_connection_t *c, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
52 ngx_http_v3_parse_decoder_t *st, u_char ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
53 |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
54 static ngx_int_t ngx_http_v3_parse_lookup(ngx_connection_t *c, |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
55 ngx_uint_t dynamic, ngx_uint_t index, ngx_str_t *name, ngx_str_t *value); |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
56 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
57 |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
58 static ngx_int_t |
| 8226 | 59 ngx_http_v3_parse_varlen_int(ngx_connection_t *c, |
| 60 ngx_http_v3_parse_varlen_int_t *st, u_char ch) | |
| 61 { | |
| 62 enum { | |
| 63 sw_start = 0, | |
| 64 sw_length_2, | |
| 65 sw_length_3, | |
| 66 sw_length_4, | |
| 67 sw_length_5, | |
| 68 sw_length_6, | |
| 69 sw_length_7, | |
| 70 sw_length_8 | |
| 71 }; | |
| 72 | |
| 73 switch (st->state) { | |
| 74 | |
| 75 case sw_start: | |
| 76 | |
| 77 st->value = ch; | |
| 78 if (st->value & 0xc0) { | |
| 79 st->state = sw_length_2; | |
| 80 break; | |
| 81 } | |
| 82 | |
| 83 goto done; | |
| 84 | |
| 85 case sw_length_2: | |
| 86 | |
| 87 st->value = (st->value << 8) + ch; | |
| 88 if ((st->value & 0xc000) == 0x4000) { | |
| 89 st->value &= 0x3fff; | |
| 90 goto done; | |
| 91 } | |
| 92 | |
| 93 st->state = sw_length_3; | |
| 94 break; | |
| 95 | |
| 96 case sw_length_4: | |
| 97 | |
| 98 st->value = (st->value << 8) + ch; | |
| 99 if ((st->value & 0xc0000000) == 0x80000000) { | |
| 100 st->value &= 0x3fffffff; | |
| 101 goto done; | |
| 102 } | |
| 103 | |
| 104 st->state = sw_length_5; | |
| 105 break; | |
| 106 | |
| 107 case sw_length_3: | |
| 108 case sw_length_5: | |
| 109 case sw_length_6: | |
| 110 case sw_length_7: | |
| 111 | |
| 112 st->value = (st->value << 8) + ch; | |
| 113 st->state++; | |
| 114 break; | |
| 115 | |
| 116 case sw_length_8: | |
| 117 | |
| 118 st->value = (st->value << 8) + ch; | |
| 119 st->value &= 0x3fffffffffffffff; | |
| 120 goto done; | |
| 121 } | |
| 122 | |
| 123 return NGX_AGAIN; | |
| 124 | |
| 125 done: | |
| 126 | |
| 127 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 128 "http3 parse varlen int %uL", st->value); | |
| 129 | |
| 130 st->state = sw_start; | |
| 131 return NGX_DONE; | |
| 132 } | |
| 133 | |
| 134 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
135 static ngx_int_t |
| 8226 | 136 ngx_http_v3_parse_prefix_int(ngx_connection_t *c, |
| 137 ngx_http_v3_parse_prefix_int_t *st, ngx_uint_t prefix, u_char ch) | |
| 138 { | |
|
8455
b0e81f49d7c0
HTTP/3: fixed prefixed integer encoding and decoding.
Roman Arutyunyan <arut@nginx.com>
parents:
8454
diff
changeset
|
139 ngx_uint_t mask; |
| 8226 | 140 enum { |
| 141 sw_start = 0, | |
| 142 sw_value | |
| 143 }; | |
| 144 | |
| 145 switch (st->state) { | |
| 146 | |
| 147 case sw_start: | |
| 148 | |
|
8455
b0e81f49d7c0
HTTP/3: fixed prefixed integer encoding and decoding.
Roman Arutyunyan <arut@nginx.com>
parents:
8454
diff
changeset
|
149 mask = (1 << prefix) - 1; |
|
b0e81f49d7c0
HTTP/3: fixed prefixed integer encoding and decoding.
Roman Arutyunyan <arut@nginx.com>
parents:
8454
diff
changeset
|
150 st->value = ch & mask; |
| 8226 | 151 |
|
8455
b0e81f49d7c0
HTTP/3: fixed prefixed integer encoding and decoding.
Roman Arutyunyan <arut@nginx.com>
parents:
8454
diff
changeset
|
152 if (st->value != mask) { |
| 8226 | 153 goto done; |
| 154 } | |
| 155 | |
|
8455
b0e81f49d7c0
HTTP/3: fixed prefixed integer encoding and decoding.
Roman Arutyunyan <arut@nginx.com>
parents:
8454
diff
changeset
|
156 st->shift = 0; |
| 8226 | 157 st->state = sw_value; |
| 158 break; | |
| 159 | |
| 160 case sw_value: | |
| 161 | |
|
8463
2576485b93d4
HTTP/3: fixed overflow in prefixed integer parser.
Roman Arutyunyan <arut@nginx.com>
parents:
8462
diff
changeset
|
162 st->value += (uint64_t) (ch & 0x7f) << st->shift; |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
163 |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
164 if (st->shift == 56 |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
165 && ((ch & 0x80) || (st->value & 0xc000000000000000))) |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
166 { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
167 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
168 "client exceeded integer size limit"); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
169 return NGX_HTTP_V3_ERR_EXCESSIVE_LOAD; |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
170 } |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
171 |
| 8226 | 172 if (ch & 0x80) { |
|
8455
b0e81f49d7c0
HTTP/3: fixed prefixed integer encoding and decoding.
Roman Arutyunyan <arut@nginx.com>
parents:
8454
diff
changeset
|
173 st->shift += 7; |
| 8226 | 174 break; |
| 175 } | |
| 176 | |
| 177 goto done; | |
| 178 } | |
| 179 | |
| 180 return NGX_AGAIN; | |
| 181 | |
| 182 done: | |
| 183 | |
| 184 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 185 "http3 parse prefix int %uL", st->value); | |
| 186 | |
| 187 st->state = sw_start; | |
| 188 return NGX_DONE; | |
| 189 } | |
| 190 | |
| 191 | |
| 192 ngx_int_t | |
| 193 ngx_http_v3_parse_headers(ngx_connection_t *c, ngx_http_v3_parse_headers_t *st, | |
| 194 u_char ch) | |
| 195 { | |
| 196 ngx_int_t rc; | |
| 197 enum { | |
| 198 sw_start = 0, | |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
199 sw_type, |
| 8226 | 200 sw_length, |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
201 sw_skip, |
| 8226 | 202 sw_prefix, |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
203 sw_verify, |
| 8226 | 204 sw_header_rep, |
| 205 sw_done | |
| 206 }; | |
| 207 | |
| 208 switch (st->state) { | |
| 209 | |
| 210 case sw_start: | |
| 211 | |
| 212 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse headers"); | |
| 213 | |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
214 st->state = sw_type; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
215 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
216 /* fall through */ |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
217 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
218 case sw_type: |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
219 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
220 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
221 if (rc != NGX_DONE) { |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
222 return rc; |
| 8226 | 223 } |
| 224 | |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
225 st->type = st->vlint.value; |
|
8550
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
226 |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
227 if (ngx_http_v3_is_v2_frame(st->type)) { |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
228 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED; |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
229 } |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
230 |
| 8226 | 231 st->state = sw_length; |
| 232 break; | |
| 233 | |
| 234 case sw_length: | |
| 235 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
236 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
237 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
238 return rc; |
| 8226 | 239 } |
| 240 | |
| 241 st->length = st->vlint.value; | |
| 242 | |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
243 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
244 "http3 parse headers type:%ui, len:%ui", |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
245 st->type, st->length); |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
246 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
247 if (st->type != NGX_HTTP_V3_FRAME_HEADERS) { |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
248 st->state = st->length > 0 ? sw_skip : sw_type; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
249 break; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
250 } |
| 8226 | 251 |
|
8552
351d62300832
HTTP/3: rearranged length check when parsing header.
Roman Arutyunyan <arut@nginx.com>
parents:
8550
diff
changeset
|
252 if (st->length == 0) { |
|
351d62300832
HTTP/3: rearranged length check when parsing header.
Roman Arutyunyan <arut@nginx.com>
parents:
8550
diff
changeset
|
253 return NGX_HTTP_V3_ERR_FRAME_ERROR; |
|
351d62300832
HTTP/3: rearranged length check when parsing header.
Roman Arutyunyan <arut@nginx.com>
parents:
8550
diff
changeset
|
254 } |
|
351d62300832
HTTP/3: rearranged length check when parsing header.
Roman Arutyunyan <arut@nginx.com>
parents:
8550
diff
changeset
|
255 |
| 8226 | 256 st->state = sw_prefix; |
| 257 break; | |
| 258 | |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
259 case sw_skip: |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
260 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
261 if (--st->length == 0) { |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
262 st->state = sw_type; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
263 } |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
264 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
265 break; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
266 |
| 8226 | 267 case sw_prefix: |
| 268 | |
|
8552
351d62300832
HTTP/3: rearranged length check when parsing header.
Roman Arutyunyan <arut@nginx.com>
parents:
8550
diff
changeset
|
269 if (--st->length == 0) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
270 return NGX_HTTP_V3_ERR_FRAME_ERROR; |
| 8226 | 271 } |
| 272 | |
| 273 rc = ngx_http_v3_parse_header_block_prefix(c, &st->prefix, ch); | |
| 274 if (rc != NGX_DONE) { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
275 return rc; |
| 8226 | 276 } |
| 277 | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
278 st->state = sw_verify; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
279 break; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
280 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
281 case sw_verify: |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
282 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
283 rc = ngx_http_v3_check_insert_count(c, st->prefix.insert_count); |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
284 if (rc != NGX_OK) { |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
285 return rc; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
286 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
287 |
| 8226 | 288 st->state = sw_header_rep; |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
289 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
290 /* fall through */ |
| 8226 | 291 |
| 292 case sw_header_rep: | |
| 293 | |
| 294 rc = ngx_http_v3_parse_header_rep(c, &st->header_rep, st->prefix.base, | |
| 295 ch); | |
| 296 | |
|
8467
e02250b55b17
HTTP/3: simplified handling return codes from parse functions.
Roman Arutyunyan <arut@nginx.com>
parents:
8466
diff
changeset
|
297 if (--st->length == 0 && rc == NGX_AGAIN) { |
|
e02250b55b17
HTTP/3: simplified handling return codes from parse functions.
Roman Arutyunyan <arut@nginx.com>
parents:
8466
diff
changeset
|
298 return NGX_HTTP_V3_ERR_FRAME_ERROR; |
| 8226 | 299 } |
| 300 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
301 if (rc != NGX_DONE) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
302 return rc; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
303 } |
| 8226 | 304 |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
305 if (st->length == 0) { |
| 8226 | 306 goto done; |
| 307 } | |
| 308 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
309 return NGX_OK; |
| 8226 | 310 } |
| 311 | |
| 312 return NGX_AGAIN; | |
| 313 | |
| 314 done: | |
| 315 | |
| 316 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse headers done"); | |
| 317 | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
318 if (st->prefix.insert_count > 0) { |
|
8771
0981329169ea
HTTP/3: renamed ngx_http_v3_client_XXX() functions.
Roman Arutyunyan <arut@nginx.com>
parents:
8765
diff
changeset
|
319 if (ngx_http_v3_send_ack_header(c, c->quic->id) != NGX_OK) { |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
320 return NGX_ERROR; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
321 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
322 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
323 |
| 8226 | 324 st->state = sw_start; |
| 325 return NGX_DONE; | |
| 326 } | |
| 327 | |
| 328 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
329 static ngx_int_t |
| 8226 | 330 ngx_http_v3_parse_header_block_prefix(ngx_connection_t *c, |
| 331 ngx_http_v3_parse_header_block_prefix_t *st, u_char ch) | |
| 332 { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
333 ngx_int_t rc; |
| 8226 | 334 enum { |
| 335 sw_start = 0, | |
| 336 sw_req_insert_count, | |
| 337 sw_delta_base, | |
| 338 sw_read_delta_base | |
| 339 }; | |
| 340 | |
| 341 switch (st->state) { | |
| 342 | |
| 343 case sw_start: | |
| 344 | |
| 345 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 346 "http3 parse header block prefix"); | |
| 347 | |
| 348 st->state = sw_req_insert_count; | |
| 349 | |
| 350 /* fall through */ | |
| 351 | |
| 352 case sw_req_insert_count: | |
| 353 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
354 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 8, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
355 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
356 return rc; |
| 8226 | 357 } |
| 358 | |
| 359 st->insert_count = st->pint.value; | |
| 360 st->state = sw_delta_base; | |
| 361 break; | |
| 362 | |
| 363 case sw_delta_base: | |
| 364 | |
| 365 st->sign = (ch & 0x80) ? 1 : 0; | |
| 366 st->state = sw_read_delta_base; | |
| 367 | |
| 368 /* fall through */ | |
| 369 | |
| 370 case sw_read_delta_base: | |
| 371 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
372 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
373 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
374 return rc; |
| 8226 | 375 } |
| 376 | |
| 377 st->delta_base = st->pint.value; | |
| 378 goto done; | |
| 379 } | |
| 380 | |
| 381 return NGX_AGAIN; | |
| 382 | |
| 383 done: | |
| 384 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
385 rc = ngx_http_v3_decode_insert_count(c, &st->insert_count); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
386 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
387 return rc; |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
388 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
389 |
| 8226 | 390 if (st->sign) { |
| 391 st->base = st->insert_count - st->delta_base - 1; | |
| 392 } else { | |
| 393 st->base = st->insert_count + st->delta_base; | |
| 394 } | |
| 395 | |
| 396 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 397 "http3 parse header block prefix done " | |
|
8478
d2f716e668e8
Fixed format specifiers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8467
diff
changeset
|
398 "insert_count:%ui, sign:%ui, delta_base:%ui, base:%ui", |
| 8226 | 399 st->insert_count, st->sign, st->delta_base, st->base); |
| 400 | |
| 401 st->state = sw_start; | |
| 402 return NGX_DONE; | |
| 403 } | |
| 404 | |
| 405 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
406 static ngx_int_t |
| 8226 | 407 ngx_http_v3_parse_header_rep(ngx_connection_t *c, |
| 408 ngx_http_v3_parse_header_rep_t *st, ngx_uint_t base, u_char ch) | |
| 409 { | |
| 410 ngx_int_t rc; | |
| 411 enum { | |
| 412 sw_start = 0, | |
| 413 sw_header_ri, | |
| 414 sw_header_lri, | |
| 415 sw_header_l, | |
| 416 sw_header_pbi, | |
| 417 sw_header_lpbi | |
| 418 }; | |
| 419 | |
| 420 if (st->state == sw_start) { | |
| 421 | |
| 422 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 423 "http3 parse header representation"); | |
| 424 | |
| 425 ngx_memzero(&st->header, sizeof(ngx_http_v3_parse_header_t)); | |
| 426 | |
| 427 st->header.base = base; | |
| 428 | |
| 429 if (ch & 0x80) { | |
| 430 /* Indexed Header Field */ | |
| 431 | |
| 432 st->state = sw_header_ri; | |
| 433 | |
| 434 } else if (ch & 0x40) { | |
| 435 /* Literal Header Field With Name Reference */ | |
| 436 | |
| 437 st->state = sw_header_lri; | |
| 438 | |
| 439 } else if (ch & 0x20) { | |
| 440 /* Literal Header Field Without Name Reference */ | |
| 441 | |
| 442 st->state = sw_header_l; | |
| 443 | |
| 444 } else if (ch & 0x10) { | |
| 445 /* Indexed Header Field With Post-Base Index */ | |
| 446 | |
| 447 st->state = sw_header_pbi; | |
| 448 | |
| 449 } else { | |
| 450 /* Literal Header Field With Post-Base Name Reference */ | |
| 451 | |
| 452 st->state = sw_header_lpbi; | |
| 453 } | |
| 454 } | |
| 455 | |
| 456 switch (st->state) { | |
| 457 | |
| 458 case sw_header_ri: | |
| 459 rc = ngx_http_v3_parse_header_ri(c, &st->header, ch); | |
| 460 break; | |
| 461 | |
| 462 case sw_header_lri: | |
| 463 rc = ngx_http_v3_parse_header_lri(c, &st->header, ch); | |
| 464 break; | |
| 465 | |
| 466 case sw_header_l: | |
| 467 rc = ngx_http_v3_parse_header_l(c, &st->header, ch); | |
| 468 break; | |
| 469 | |
| 470 case sw_header_pbi: | |
| 471 rc = ngx_http_v3_parse_header_pbi(c, &st->header, ch); | |
| 472 break; | |
| 473 | |
| 474 case sw_header_lpbi: | |
| 475 rc = ngx_http_v3_parse_header_lpbi(c, &st->header, ch); | |
| 476 break; | |
| 477 | |
| 478 default: | |
| 479 rc = NGX_OK; | |
| 480 } | |
| 481 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
482 if (rc != NGX_DONE) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
483 return rc; |
| 8226 | 484 } |
| 485 | |
| 486 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 487 "http3 parse header representation done"); | |
| 488 | |
| 489 st->state = sw_start; | |
| 490 return NGX_DONE; | |
| 491 } | |
| 492 | |
| 493 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
494 static ngx_int_t |
| 8226 | 495 ngx_http_v3_parse_literal(ngx_connection_t *c, ngx_http_v3_parse_literal_t *st, |
| 496 u_char ch) | |
| 497 { | |
|
8705
ae2e68f206f9
HTTP/3: removed http3_max_field_size.
Roman Arutyunyan <arut@nginx.com>
parents:
8666
diff
changeset
|
498 ngx_uint_t n; |
|
ae2e68f206f9
HTTP/3: removed http3_max_field_size.
Roman Arutyunyan <arut@nginx.com>
parents:
8666
diff
changeset
|
499 ngx_http_core_srv_conf_t *cscf; |
| 8226 | 500 enum { |
| 501 sw_start = 0, | |
| 502 sw_value | |
| 503 }; | |
| 504 | |
| 505 switch (st->state) { | |
| 506 | |
| 507 case sw_start: | |
| 508 | |
| 509 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 510 "http3 parse literal huff:%ui, len:%ui", | |
| 511 st->huffman, st->length); | |
| 512 | |
| 513 n = st->length; | |
| 514 | |
|
8705
ae2e68f206f9
HTTP/3: removed http3_max_field_size.
Roman Arutyunyan <arut@nginx.com>
parents:
8666
diff
changeset
|
515 cscf = ngx_http_v3_get_module_srv_conf(c, ngx_http_core_module); |
|
8454
032cb35ce758
HTTP/3: http3_max_field_size directive to limit string size.
Roman Arutyunyan <arut@nginx.com>
parents:
8295
diff
changeset
|
516 |
|
8705
ae2e68f206f9
HTTP/3: removed http3_max_field_size.
Roman Arutyunyan <arut@nginx.com>
parents:
8666
diff
changeset
|
517 if (n > cscf->large_client_header_buffers.size) { |
|
8457
a7f64438aa3c
HTTP/3: downgraded literal size error level to NGX_LOG_INFO.
Roman Arutyunyan <arut@nginx.com>
parents:
8456
diff
changeset
|
518 ngx_log_error(NGX_LOG_INFO, c->log, 0, |
|
8705
ae2e68f206f9
HTTP/3: removed http3_max_field_size.
Roman Arutyunyan <arut@nginx.com>
parents:
8666
diff
changeset
|
519 "client sent too large header field"); |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
520 return NGX_HTTP_V3_ERR_EXCESSIVE_LOAD; |
|
8454
032cb35ce758
HTTP/3: http3_max_field_size directive to limit string size.
Roman Arutyunyan <arut@nginx.com>
parents:
8295
diff
changeset
|
521 } |
|
032cb35ce758
HTTP/3: http3_max_field_size directive to limit string size.
Roman Arutyunyan <arut@nginx.com>
parents:
8295
diff
changeset
|
522 |
| 8226 | 523 if (st->huffman) { |
| 524 n = n * 8 / 5; | |
| 525 st->huffstate = 0; | |
| 526 } | |
| 527 | |
| 528 st->last = ngx_pnalloc(c->pool, n + 1); | |
| 529 if (st->last == NULL) { | |
| 530 return NGX_ERROR; | |
| 531 } | |
| 532 | |
| 533 st->value.data = st->last; | |
| 534 st->state = sw_value; | |
| 535 | |
| 536 /* fall through */ | |
| 537 | |
| 538 case sw_value: | |
| 539 | |
| 540 if (st->huffman) { | |
| 541 if (ngx_http_v2_huff_decode(&st->huffstate, &ch, 1, &st->last, | |
| 542 st->length == 1, c->log) | |
| 543 != NGX_OK) | |
| 544 { | |
| 545 return NGX_ERROR; | |
| 546 } | |
| 547 | |
| 548 } else { | |
| 549 *st->last++ = ch; | |
| 550 } | |
| 551 | |
| 552 if (--st->length) { | |
| 553 break; | |
| 554 } | |
| 555 | |
| 556 st->value.len = st->last - st->value.data; | |
| 557 *st->last = '\0'; | |
| 558 goto done; | |
| 559 } | |
| 560 | |
| 561 return NGX_AGAIN; | |
| 562 | |
| 563 done: | |
| 564 | |
| 565 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 566 "http3 parse literal done \"%V\"", &st->value); | |
| 567 | |
| 568 st->state = sw_start; | |
| 569 return NGX_DONE; | |
| 570 } | |
| 571 | |
| 572 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
573 static ngx_int_t |
| 8226 | 574 ngx_http_v3_parse_header_ri(ngx_connection_t *c, ngx_http_v3_parse_header_t *st, |
| 575 u_char ch) | |
| 576 { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
577 ngx_int_t rc; |
| 8226 | 578 enum { |
| 579 sw_start = 0, | |
| 580 sw_index | |
| 581 }; | |
| 582 | |
| 583 switch (st->state) { | |
| 584 | |
| 585 case sw_start: | |
| 586 | |
| 587 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse header ri"); | |
| 588 | |
| 589 st->dynamic = (ch & 0x40) ? 0 : 1; | |
| 590 st->state = sw_index; | |
| 591 | |
| 592 /* fall through */ | |
| 593 | |
| 594 case sw_index: | |
| 595 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
596 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
597 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
598 return rc; |
| 8226 | 599 } |
| 600 | |
| 601 st->index = st->pint.value; | |
| 602 goto done; | |
| 603 } | |
| 604 | |
| 605 return NGX_AGAIN; | |
| 606 | |
| 607 done: | |
| 608 | |
| 609 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 610 "http3 parse header ri done %s%ui]", | |
| 611 st->dynamic ? "dynamic[-" : "static[", st->index); | |
| 612 | |
| 613 if (st->dynamic) { | |
| 614 st->index = st->base - st->index - 1; | |
| 615 } | |
| 616 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
617 rc = ngx_http_v3_parse_lookup(c, st->dynamic, st->index, &st->name, |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
618 &st->value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
619 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
620 return rc; |
| 8226 | 621 } |
| 622 | |
| 623 st->state = sw_start; | |
| 624 return NGX_DONE; | |
| 625 } | |
| 626 | |
| 627 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
628 static ngx_int_t |
| 8226 | 629 ngx_http_v3_parse_header_lri(ngx_connection_t *c, |
| 630 ngx_http_v3_parse_header_t *st, u_char ch) | |
| 631 { | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
632 ngx_int_t rc; |
| 8226 | 633 enum { |
| 634 sw_start = 0, | |
| 635 sw_index, | |
| 636 sw_value_len, | |
| 637 sw_read_value_len, | |
| 638 sw_value | |
| 639 }; | |
| 640 | |
| 641 switch (st->state) { | |
| 642 | |
| 643 case sw_start: | |
| 644 | |
| 645 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse header lri"); | |
| 646 | |
| 647 st->dynamic = (ch & 0x10) ? 0 : 1; | |
| 648 st->state = sw_index; | |
| 649 | |
| 650 /* fall through */ | |
| 651 | |
| 652 case sw_index: | |
| 653 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
654 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 4, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
655 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
656 return rc; |
| 8226 | 657 } |
| 658 | |
| 659 st->index = st->pint.value; | |
| 660 st->state = sw_value_len; | |
| 661 break; | |
| 662 | |
| 663 case sw_value_len: | |
| 664 | |
| 665 st->literal.huffman = (ch & 0x80) ? 1 : 0; | |
| 666 st->state = sw_read_value_len; | |
| 667 | |
| 668 /* fall through */ | |
| 669 | |
| 670 case sw_read_value_len: | |
| 671 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
672 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
673 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
674 return rc; |
| 8226 | 675 } |
| 676 | |
| 677 st->literal.length = st->pint.value; | |
| 678 if (st->literal.length == 0) { | |
| 679 goto done; | |
| 680 } | |
| 681 | |
| 682 st->state = sw_value; | |
| 683 break; | |
| 684 | |
| 685 case sw_value: | |
| 686 | |
| 687 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
688 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
689 return rc; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
690 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
691 |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
692 st->value = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
693 goto done; |
| 8226 | 694 } |
| 695 | |
| 696 return NGX_AGAIN; | |
| 697 | |
| 698 done: | |
| 699 | |
| 700 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 701 "http3 parse header lri done %s%ui] \"%V\"", | |
| 702 st->dynamic ? "dynamic[-" : "static[", | |
| 703 st->index, &st->value); | |
| 704 | |
| 705 if (st->dynamic) { | |
| 706 st->index = st->base - st->index - 1; | |
| 707 } | |
| 708 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
709 rc = ngx_http_v3_parse_lookup(c, st->dynamic, st->index, &st->name, NULL); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
710 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
711 return rc; |
| 8226 | 712 } |
| 713 | |
| 714 st->state = sw_start; | |
| 715 return NGX_DONE; | |
| 716 } | |
| 717 | |
| 718 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
719 static ngx_int_t |
| 8226 | 720 ngx_http_v3_parse_header_l(ngx_connection_t *c, |
| 721 ngx_http_v3_parse_header_t *st, u_char ch) | |
| 722 { | |
| 723 ngx_int_t rc; | |
| 724 enum { | |
| 725 sw_start = 0, | |
| 726 sw_name_len, | |
| 727 sw_name, | |
| 728 sw_value_len, | |
| 729 sw_read_value_len, | |
| 730 sw_value | |
| 731 }; | |
| 732 | |
| 733 switch (st->state) { | |
| 734 | |
| 735 case sw_start: | |
| 736 | |
| 737 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse header l"); | |
| 738 | |
| 739 st->literal.huffman = (ch & 0x08) ? 1 : 0; | |
| 740 st->state = sw_name_len; | |
| 741 | |
| 742 /* fall through */ | |
| 743 | |
| 744 case sw_name_len: | |
| 745 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
746 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 3, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
747 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
748 return rc; |
| 8226 | 749 } |
| 750 | |
| 751 st->literal.length = st->pint.value; | |
| 752 if (st->literal.length == 0) { | |
| 753 return NGX_ERROR; | |
| 754 } | |
| 755 | |
| 756 st->state = sw_name; | |
| 757 break; | |
| 758 | |
| 759 case sw_name: | |
| 760 | |
| 761 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
762 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
763 return rc; |
| 8226 | 764 } |
| 765 | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
766 st->name = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
767 st->state = sw_value_len; |
| 8226 | 768 break; |
| 769 | |
| 770 case sw_value_len: | |
| 771 | |
| 772 st->literal.huffman = (ch & 0x80) ? 1 : 0; | |
| 773 st->state = sw_read_value_len; | |
| 774 | |
| 775 /* fall through */ | |
| 776 | |
| 777 case sw_read_value_len: | |
| 778 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
779 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
780 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
781 return rc; |
| 8226 | 782 } |
| 783 | |
| 784 st->literal.length = st->pint.value; | |
| 785 if (st->literal.length == 0) { | |
|
8649
5a92523e50d3
HTTP/3: null-terminate empty header value.
Roman Arutyunyan <arut@nginx.com>
parents:
8630
diff
changeset
|
786 st->value.data = (u_char *) ""; |
| 8226 | 787 goto done; |
| 788 } | |
| 789 | |
| 790 st->state = sw_value; | |
| 791 break; | |
| 792 | |
| 793 case sw_value: | |
| 794 | |
| 795 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
796 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
797 return rc; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
798 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
799 |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
800 st->value = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
801 goto done; |
| 8226 | 802 } |
| 803 | |
| 804 return NGX_AGAIN; | |
| 805 | |
| 806 done: | |
| 807 | |
| 808 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 809 "http3 parse header l done \"%V\" \"%V\"", | |
| 810 &st->name, &st->value); | |
| 811 | |
| 812 st->state = sw_start; | |
| 813 return NGX_DONE; | |
| 814 } | |
| 815 | |
| 816 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
817 static ngx_int_t |
| 8226 | 818 ngx_http_v3_parse_header_pbi(ngx_connection_t *c, |
| 819 ngx_http_v3_parse_header_t *st, u_char ch) | |
| 820 { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
821 ngx_int_t rc; |
| 8226 | 822 enum { |
| 823 sw_start = 0, | |
| 824 sw_index | |
| 825 }; | |
| 826 | |
| 827 switch (st->state) { | |
| 828 | |
| 829 case sw_start: | |
| 830 | |
| 831 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse header pbi"); | |
| 832 | |
| 833 st->state = sw_index; | |
| 834 | |
| 835 /* fall through */ | |
| 836 | |
| 837 case sw_index: | |
| 838 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
839 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 4, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
840 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
841 return rc; |
| 8226 | 842 } |
| 843 | |
| 844 st->index = st->pint.value; | |
| 845 goto done; | |
| 846 } | |
| 847 | |
| 848 return NGX_AGAIN; | |
| 849 | |
| 850 done: | |
| 851 | |
| 852 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 853 "http3 parse header pbi done dynamic[+%ui]", st->index); | |
| 854 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
855 rc = ngx_http_v3_parse_lookup(c, 1, st->base + st->index, &st->name, |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
856 &st->value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
857 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
858 return rc; |
| 8226 | 859 } |
| 860 | |
| 861 st->state = sw_start; | |
| 862 return NGX_DONE; | |
| 863 } | |
| 864 | |
| 865 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
866 static ngx_int_t |
| 8226 | 867 ngx_http_v3_parse_header_lpbi(ngx_connection_t *c, |
| 868 ngx_http_v3_parse_header_t *st, u_char ch) | |
| 869 { | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
870 ngx_int_t rc; |
| 8226 | 871 enum { |
| 872 sw_start = 0, | |
| 873 sw_index, | |
| 874 sw_value_len, | |
| 875 sw_read_value_len, | |
| 876 sw_value | |
| 877 }; | |
| 878 | |
| 879 switch (st->state) { | |
| 880 | |
| 881 case sw_start: | |
| 882 | |
| 883 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 884 "http3 parse header lpbi"); | |
| 885 | |
| 886 st->state = sw_index; | |
| 887 | |
| 888 /* fall through */ | |
| 889 | |
| 890 case sw_index: | |
| 891 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
892 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 3, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
893 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
894 return rc; |
| 8226 | 895 } |
| 896 | |
| 897 st->index = st->pint.value; | |
| 898 st->state = sw_value_len; | |
| 899 break; | |
| 900 | |
| 901 case sw_value_len: | |
| 902 | |
| 903 st->literal.huffman = (ch & 0x80) ? 1 : 0; | |
| 904 st->state = sw_read_value_len; | |
| 905 | |
| 906 /* fall through */ | |
| 907 | |
| 908 case sw_read_value_len: | |
| 909 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
910 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
911 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
912 return rc; |
| 8226 | 913 } |
| 914 | |
| 915 st->literal.length = st->pint.value; | |
| 916 if (st->literal.length == 0) { | |
| 917 goto done; | |
| 918 } | |
| 919 | |
| 920 st->state = sw_value; | |
| 921 break; | |
| 922 | |
| 923 case sw_value: | |
| 924 | |
| 925 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
926 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
927 return rc; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
928 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
929 |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
930 st->value = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
931 goto done; |
| 8226 | 932 } |
| 933 | |
| 934 return NGX_AGAIN; | |
| 935 | |
| 936 done: | |
| 937 | |
| 938 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 939 "http3 parse header lpbi done dynamic[+%ui] \"%V\"", | |
| 940 st->index, &st->value); | |
| 941 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
942 rc = ngx_http_v3_parse_lookup(c, 1, st->base + st->index, &st->name, NULL); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
943 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
944 return rc; |
| 8226 | 945 } |
| 946 | |
| 947 st->state = sw_start; | |
| 948 return NGX_DONE; | |
| 949 } | |
| 950 | |
| 951 | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
952 static ngx_int_t |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
953 ngx_http_v3_parse_lookup(ngx_connection_t *c, ngx_uint_t dynamic, |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
954 ngx_uint_t index, ngx_str_t *name, ngx_str_t *value) |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
955 { |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
956 u_char *p; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
957 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
958 if (!dynamic) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
959 if (ngx_http_v3_lookup_static(c, index, name, value) != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
960 return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
961 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
962 |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
963 return NGX_OK; |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
964 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
965 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
966 if (ngx_http_v3_lookup(c, index, name, value) != NGX_OK) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
967 return NGX_HTTP_V3_ERR_DECOMPRESSION_FAILED; |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
968 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
969 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
970 if (name) { |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
971 p = ngx_pnalloc(c->pool, name->len + 1); |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
972 if (p == NULL) { |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
973 return NGX_ERROR; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
974 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
975 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
976 ngx_memcpy(p, name->data, name->len); |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
977 p[name->len] = '\0'; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
978 name->data = p; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
979 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
980 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
981 if (value) { |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
982 p = ngx_pnalloc(c->pool, value->len + 1); |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
983 if (p == NULL) { |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
984 return NGX_ERROR; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
985 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
986 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
987 ngx_memcpy(p, value->data, value->len); |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
988 p[value->len] = '\0'; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
989 value->data = p; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
990 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
991 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
992 return NGX_OK; |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
993 } |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
994 |
|
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
995 |
|
8772
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
996 static ngx_int_t |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
997 ngx_http_v3_parse_control(ngx_connection_t *c, ngx_http_v3_parse_control_t *st, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
998 u_char ch) |
| 8226 | 999 { |
| 1000 ngx_int_t rc; | |
| 1001 enum { | |
| 1002 sw_start = 0, | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1003 sw_first_type, |
| 8226 | 1004 sw_type, |
| 1005 sw_length, | |
| 8497 | 1006 sw_cancel_push, |
| 8226 | 1007 sw_settings, |
| 1008 sw_max_push_id, | |
| 1009 sw_skip | |
| 1010 }; | |
| 1011 | |
| 1012 switch (st->state) { | |
| 1013 | |
| 1014 case sw_start: | |
| 1015 | |
| 1016 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse control"); | |
| 1017 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1018 st->state = sw_first_type; |
| 8226 | 1019 |
| 1020 /* fall through */ | |
| 1021 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1022 case sw_first_type: |
| 8226 | 1023 case sw_type: |
| 1024 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1025 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1026 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1027 return rc; |
| 8226 | 1028 } |
| 1029 | |
| 1030 st->type = st->vlint.value; | |
| 1031 | |
| 1032 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1033 "http3 parse frame type:%ui", st->type); | |
| 1034 | |
|
8765
687445803d0f
HTTP/3: reject empty DATA and HEADERS frames on control stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8762
diff
changeset
|
1035 if (ngx_http_v3_is_v2_frame(st->type) |
|
687445803d0f
HTTP/3: reject empty DATA and HEADERS frames on control stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8762
diff
changeset
|
1036 || st->type == NGX_HTTP_V3_FRAME_DATA |
|
687445803d0f
HTTP/3: reject empty DATA and HEADERS frames on control stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8762
diff
changeset
|
1037 || st->type == NGX_HTTP_V3_FRAME_HEADERS) |
|
687445803d0f
HTTP/3: reject empty DATA and HEADERS frames on control stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8762
diff
changeset
|
1038 { |
|
8550
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1039 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED; |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1040 } |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1041 |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1042 if (st->state == sw_first_type |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1043 && st->type != NGX_HTTP_V3_FRAME_SETTINGS) |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1044 { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1045 return NGX_HTTP_V3_ERR_MISSING_SETTINGS; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1046 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1047 |
| 8226 | 1048 st->state = sw_length; |
| 1049 break; | |
| 1050 | |
| 1051 case sw_length: | |
| 1052 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1053 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1054 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1055 return rc; |
| 8226 | 1056 } |
| 1057 | |
| 1058 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1059 "http3 parse frame len:%uL", st->vlint.value); | |
| 1060 | |
| 1061 st->length = st->vlint.value; | |
| 1062 if (st->length == 0) { | |
| 1063 st->state = sw_type; | |
| 1064 break; | |
| 1065 } | |
| 1066 | |
| 1067 switch (st->type) { | |
| 1068 | |
| 8497 | 1069 case NGX_HTTP_V3_FRAME_CANCEL_PUSH: |
| 1070 st->state = sw_cancel_push; | |
| 1071 break; | |
| 1072 | |
| 8226 | 1073 case NGX_HTTP_V3_FRAME_SETTINGS: |
| 1074 st->state = sw_settings; | |
| 1075 break; | |
| 1076 | |
| 1077 case NGX_HTTP_V3_FRAME_MAX_PUSH_ID: | |
| 1078 st->state = sw_max_push_id; | |
| 1079 break; | |
| 1080 | |
| 1081 default: | |
| 1082 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1083 "http3 parse skip unknown frame"); | |
| 1084 st->state = sw_skip; | |
| 1085 } | |
| 1086 | |
| 1087 break; | |
| 1088 | |
| 8497 | 1089 case sw_cancel_push: |
| 1090 | |
| 1091 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); | |
| 1092 | |
| 1093 if (--st->length == 0 && rc == NGX_AGAIN) { | |
| 1094 return NGX_HTTP_V3_ERR_FRAME_ERROR; | |
| 1095 } | |
| 1096 | |
| 1097 if (rc != NGX_DONE) { | |
| 1098 return rc; | |
| 1099 } | |
| 1100 | |
| 1101 rc = ngx_http_v3_cancel_push(c, st->vlint.value); | |
| 1102 if (rc != NGX_OK) { | |
| 1103 return rc; | |
| 1104 } | |
| 1105 | |
| 1106 st->state = sw_type; | |
| 1107 break; | |
| 1108 | |
| 8226 | 1109 case sw_settings: |
| 1110 | |
| 1111 rc = ngx_http_v3_parse_settings(c, &st->settings, ch); | |
| 1112 | |
|
8467
e02250b55b17
HTTP/3: simplified handling return codes from parse functions.
Roman Arutyunyan <arut@nginx.com>
parents:
8466
diff
changeset
|
1113 if (--st->length == 0 && rc == NGX_AGAIN) { |
|
e02250b55b17
HTTP/3: simplified handling return codes from parse functions.
Roman Arutyunyan <arut@nginx.com>
parents:
8466
diff
changeset
|
1114 return NGX_HTTP_V3_ERR_SETTINGS_ERROR; |
| 8226 | 1115 } |
| 1116 | |
| 1117 if (rc != NGX_DONE) { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1118 return rc; |
| 8226 | 1119 } |
| 1120 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1121 if (st->length == 0) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1122 st->state = sw_type; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1123 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1124 |
| 8226 | 1125 break; |
| 1126 | |
| 1127 case sw_max_push_id: | |
| 1128 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1129 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
| 8497 | 1130 |
| 1131 if (--st->length == 0 && rc == NGX_AGAIN) { | |
| 1132 return NGX_HTTP_V3_ERR_FRAME_ERROR; | |
| 1133 } | |
| 1134 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1135 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1136 return rc; |
| 8226 | 1137 } |
| 1138 | |
| 8497 | 1139 rc = ngx_http_v3_set_max_push_id(c, st->vlint.value); |
| 1140 if (rc != NGX_OK) { | |
| 1141 return rc; | |
| 1142 } | |
| 8226 | 1143 |
| 1144 st->state = sw_type; | |
| 1145 break; | |
| 1146 | |
| 1147 case sw_skip: | |
| 1148 | |
| 1149 if (--st->length == 0) { | |
| 1150 st->state = sw_type; | |
| 1151 } | |
| 1152 | |
| 1153 break; | |
| 1154 } | |
| 1155 | |
| 1156 return NGX_AGAIN; | |
| 1157 } | |
| 1158 | |
| 1159 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
1160 static ngx_int_t |
| 8226 | 1161 ngx_http_v3_parse_settings(ngx_connection_t *c, |
| 1162 ngx_http_v3_parse_settings_t *st, u_char ch) | |
| 1163 { | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1164 ngx_int_t rc; |
| 8226 | 1165 enum { |
| 1166 sw_start = 0, | |
| 1167 sw_id, | |
| 1168 sw_value | |
| 1169 }; | |
| 1170 | |
| 1171 switch (st->state) { | |
| 1172 | |
| 1173 case sw_start: | |
| 1174 | |
| 1175 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse settings"); | |
| 1176 | |
| 1177 st->state = sw_id; | |
| 1178 | |
| 1179 /* fall through */ | |
| 1180 | |
| 1181 case sw_id: | |
| 1182 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1183 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1184 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1185 return rc; |
| 8226 | 1186 } |
| 1187 | |
| 1188 st->id = st->vlint.value; | |
| 1189 st->state = sw_value; | |
| 1190 break; | |
| 1191 | |
| 1192 case sw_value: | |
| 1193 | |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1194 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1195 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1196 return rc; |
| 8226 | 1197 } |
| 1198 | |
| 1199 if (ngx_http_v3_set_param(c, st->id, st->vlint.value) != NGX_OK) { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1200 return NGX_HTTP_V3_ERR_SETTINGS_ERROR; |
| 8226 | 1201 } |
| 1202 | |
| 1203 goto done; | |
| 1204 } | |
| 1205 | |
| 1206 return NGX_AGAIN; | |
| 1207 | |
| 1208 done: | |
| 1209 | |
| 1210 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse settings done"); | |
| 1211 | |
| 1212 st->state = sw_start; | |
| 1213 return NGX_DONE; | |
| 1214 } | |
| 1215 | |
| 1216 | |
|
8772
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1217 static ngx_int_t |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1218 ngx_http_v3_parse_encoder(ngx_connection_t *c, ngx_http_v3_parse_encoder_t *st, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1219 u_char ch) |
| 8226 | 1220 { |
| 1221 ngx_int_t rc; | |
| 1222 enum { | |
| 1223 sw_start = 0, | |
| 1224 sw_inr, | |
| 1225 sw_iwnr, | |
| 1226 sw_capacity, | |
| 1227 sw_duplicate | |
| 1228 }; | |
| 1229 | |
| 1230 if (st->state == sw_start) { | |
| 1231 | |
| 1232 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1233 "http3 parse encoder instruction"); | |
| 1234 | |
| 1235 if (ch & 0x80) { | |
| 1236 /* Insert With Name Reference */ | |
| 1237 | |
| 1238 st->state = sw_inr; | |
| 1239 | |
| 1240 } else if (ch & 0x40) { | |
| 1241 /* Insert Without Name Reference */ | |
| 1242 | |
| 1243 st->state = sw_iwnr; | |
| 1244 | |
| 1245 } else if (ch & 0x20) { | |
| 1246 /* Set Dynamic Table Capacity */ | |
| 1247 | |
| 1248 st->state = sw_capacity; | |
| 1249 | |
| 1250 } else { | |
| 1251 /* Duplicate */ | |
| 1252 | |
| 1253 st->state = sw_duplicate; | |
| 1254 } | |
| 1255 } | |
| 1256 | |
| 1257 switch (st->state) { | |
| 1258 | |
| 1259 case sw_inr: | |
| 1260 | |
| 1261 rc = ngx_http_v3_parse_header_inr(c, &st->header, ch); | |
| 1262 if (rc != NGX_DONE) { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1263 return rc; |
| 8226 | 1264 } |
| 1265 | |
| 1266 goto done; | |
| 1267 | |
| 1268 case sw_iwnr: | |
| 1269 | |
| 1270 rc = ngx_http_v3_parse_header_iwnr(c, &st->header, ch); | |
| 1271 if (rc != NGX_DONE) { | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1272 return rc; |
| 8226 | 1273 } |
| 1274 | |
| 1275 goto done; | |
| 1276 | |
| 1277 case sw_capacity: | |
| 1278 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1279 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1280 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1281 return rc; |
| 8226 | 1282 } |
| 1283 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1284 rc = ngx_http_v3_set_capacity(c, st->pint.value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1285 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1286 return rc; |
| 8226 | 1287 } |
| 1288 | |
| 1289 goto done; | |
| 1290 | |
| 1291 case sw_duplicate: | |
| 1292 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1293 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1294 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1295 return rc; |
| 8226 | 1296 } |
| 1297 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1298 rc = ngx_http_v3_duplicate(c, st->pint.value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1299 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1300 return rc; |
| 8226 | 1301 } |
| 1302 | |
| 1303 goto done; | |
| 1304 } | |
| 1305 | |
| 1306 return NGX_AGAIN; | |
| 1307 | |
| 1308 done: | |
| 1309 | |
| 1310 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1311 "http3 parse encoder instruction done"); | |
| 1312 | |
| 1313 st->state = sw_start; | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
1314 return NGX_AGAIN; |
| 8226 | 1315 } |
| 1316 | |
| 1317 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
1318 static ngx_int_t |
| 8226 | 1319 ngx_http_v3_parse_header_inr(ngx_connection_t *c, |
| 1320 ngx_http_v3_parse_header_t *st, u_char ch) | |
| 1321 { | |
| 1322 ngx_int_t rc; | |
| 1323 enum { | |
| 1324 sw_start = 0, | |
| 1325 sw_name_index, | |
| 1326 sw_value_len, | |
| 1327 sw_read_value_len, | |
| 1328 sw_value | |
| 1329 }; | |
| 1330 | |
| 1331 switch (st->state) { | |
| 1332 | |
| 1333 case sw_start: | |
| 1334 | |
| 1335 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse header inr"); | |
| 1336 | |
| 1337 st->dynamic = (ch & 0x40) ? 0 : 1; | |
| 1338 st->state = sw_name_index; | |
| 1339 | |
| 1340 /* fall through */ | |
| 1341 | |
| 1342 case sw_name_index: | |
| 1343 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1344 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1345 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1346 return rc; |
| 8226 | 1347 } |
| 1348 | |
| 1349 st->index = st->pint.value; | |
| 1350 st->state = sw_value_len; | |
| 1351 break; | |
| 1352 | |
| 1353 case sw_value_len: | |
| 1354 | |
| 1355 st->literal.huffman = (ch & 0x80) ? 1 : 0; | |
| 1356 st->state = sw_read_value_len; | |
| 1357 | |
| 1358 /* fall through */ | |
| 1359 | |
| 1360 case sw_read_value_len: | |
| 1361 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1362 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1363 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1364 return rc; |
| 8226 | 1365 } |
| 1366 | |
| 1367 st->literal.length = st->pint.value; | |
| 1368 if (st->literal.length == 0) { | |
| 1369 goto done; | |
| 1370 } | |
| 1371 | |
| 1372 st->state = sw_value; | |
| 1373 break; | |
| 1374 | |
| 1375 case sw_value: | |
| 1376 | |
| 1377 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1378 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1379 return rc; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1380 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1381 |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1382 st->value = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1383 goto done; |
| 8226 | 1384 } |
| 1385 | |
| 1386 return NGX_AGAIN; | |
| 1387 | |
| 1388 done: | |
| 1389 | |
| 1390 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1391 "http3 parse header inr done %s[%ui] \"%V\"", | |
| 1392 st->dynamic ? "dynamic" : "static", | |
| 1393 st->index, &st->value); | |
| 1394 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1395 rc = ngx_http_v3_ref_insert(c, st->dynamic, st->index, &st->value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1396 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1397 return rc; |
| 8226 | 1398 } |
| 1399 | |
| 1400 st->state = sw_start; | |
| 1401 return NGX_DONE; | |
| 1402 } | |
| 1403 | |
| 1404 | |
|
8666
ab6aaa8e86b0
HTTP/3: staticize internal parsing functions.
Sergey Kandaurov <pluknet@nginx.com>
parents:
8649
diff
changeset
|
1405 static ngx_int_t |
| 8226 | 1406 ngx_http_v3_parse_header_iwnr(ngx_connection_t *c, |
| 1407 ngx_http_v3_parse_header_t *st, u_char ch) | |
| 1408 { | |
| 1409 ngx_int_t rc; | |
| 1410 enum { | |
| 1411 sw_start = 0, | |
| 1412 sw_name_len, | |
| 1413 sw_name, | |
| 1414 sw_value_len, | |
| 1415 sw_read_value_len, | |
| 1416 sw_value | |
| 1417 }; | |
| 1418 | |
| 1419 switch (st->state) { | |
| 1420 | |
| 1421 case sw_start: | |
| 1422 | |
| 1423 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1424 "http3 parse header iwnr"); | |
| 1425 | |
| 1426 st->literal.huffman = (ch & 0x20) ? 1 : 0; | |
| 1427 st->state = sw_name_len; | |
| 1428 | |
| 1429 /* fall through */ | |
| 1430 | |
| 1431 case sw_name_len: | |
| 1432 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1433 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 5, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1434 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1435 return rc; |
| 8226 | 1436 } |
| 1437 | |
| 1438 st->literal.length = st->pint.value; | |
| 1439 if (st->literal.length == 0) { | |
| 1440 return NGX_ERROR; | |
| 1441 } | |
| 1442 | |
| 1443 st->state = sw_name; | |
| 1444 break; | |
| 1445 | |
| 1446 case sw_name: | |
| 1447 | |
| 1448 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1449 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1450 return rc; |
| 8226 | 1451 } |
| 1452 | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1453 st->name = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1454 st->state = sw_value_len; |
| 8226 | 1455 break; |
| 1456 | |
| 1457 case sw_value_len: | |
| 1458 | |
| 1459 st->literal.huffman = (ch & 0x80) ? 1 : 0; | |
| 1460 st->state = sw_read_value_len; | |
| 1461 | |
| 1462 /* fall through */ | |
| 1463 | |
| 1464 case sw_read_value_len: | |
| 1465 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1466 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1467 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1468 return rc; |
| 8226 | 1469 } |
| 1470 | |
| 1471 st->literal.length = st->pint.value; | |
| 1472 if (st->literal.length == 0) { | |
| 1473 goto done; | |
| 1474 } | |
| 1475 | |
| 1476 st->state = sw_value; | |
| 1477 break; | |
| 1478 | |
| 1479 case sw_value: | |
| 1480 | |
| 1481 rc = ngx_http_v3_parse_literal(c, &st->literal, ch); | |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1482 if (rc != NGX_DONE) { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1483 return rc; |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1484 } |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1485 |
|
8465
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1486 st->value = st->literal.value; |
|
5611bbb852ce
HTTP/3: simplifed handling ngx_http_v3_parse_literal() return code.
Roman Arutyunyan <arut@nginx.com>
parents:
8464
diff
changeset
|
1487 goto done; |
| 8226 | 1488 } |
| 1489 | |
| 1490 return NGX_AGAIN; | |
| 1491 | |
| 1492 done: | |
| 1493 | |
| 1494 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1495 "http3 parse header iwnr done \"%V\":\"%V\"", | |
| 1496 &st->name, &st->value); | |
| 1497 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1498 rc = ngx_http_v3_insert(c, &st->name, &st->value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1499 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1500 return rc; |
| 8226 | 1501 } |
| 1502 | |
| 1503 st->state = sw_start; | |
| 1504 return NGX_DONE; | |
| 1505 } | |
| 1506 | |
| 1507 | |
|
8772
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1508 static ngx_int_t |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1509 ngx_http_v3_parse_decoder(ngx_connection_t *c, ngx_http_v3_parse_decoder_t *st, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1510 u_char ch) |
| 8226 | 1511 { |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1512 ngx_int_t rc; |
| 8226 | 1513 enum { |
| 1514 sw_start = 0, | |
| 1515 sw_ack_header, | |
| 1516 sw_cancel_stream, | |
| 1517 sw_inc_insert_count | |
| 1518 }; | |
| 1519 | |
| 1520 if (st->state == sw_start) { | |
| 1521 | |
| 1522 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1523 "http3 parse decoder instruction"); | |
| 1524 | |
| 1525 if (ch & 0x80) { | |
| 1526 /* Header Acknowledgement */ | |
| 1527 | |
| 1528 st->state = sw_ack_header; | |
| 1529 | |
| 1530 } else if (ch & 0x40) { | |
| 1531 /* Stream Cancellation */ | |
| 1532 | |
| 1533 st->state = sw_cancel_stream; | |
| 1534 | |
| 1535 } else { | |
| 1536 /* Insert Count Increment */ | |
| 1537 | |
| 1538 st->state = sw_inc_insert_count; | |
| 1539 } | |
| 1540 } | |
| 1541 | |
| 1542 switch (st->state) { | |
| 1543 | |
| 1544 case sw_ack_header: | |
| 1545 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1546 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 7, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1547 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1548 return rc; |
| 8226 | 1549 } |
| 1550 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1551 rc = ngx_http_v3_ack_header(c, st->pint.value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1552 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1553 return rc; |
| 8226 | 1554 } |
| 1555 | |
| 1556 goto done; | |
| 1557 | |
| 1558 case sw_cancel_stream: | |
| 1559 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1560 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1561 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1562 return rc; |
| 8226 | 1563 } |
| 1564 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1565 rc = ngx_http_v3_cancel_stream(c, st->pint.value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1566 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1567 return rc; |
| 8226 | 1568 } |
| 1569 | |
| 1570 goto done; | |
| 1571 | |
| 1572 case sw_inc_insert_count: | |
| 1573 | |
|
8464
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1574 rc = ngx_http_v3_parse_prefix_int(c, &st->pint, 6, ch); |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1575 if (rc != NGX_DONE) { |
|
fdb8edc8e496
HTTP/3: limited prefixed integer size by 62 bits.
Roman Arutyunyan <arut@nginx.com>
parents:
8463
diff
changeset
|
1576 return rc; |
| 8226 | 1577 } |
| 1578 | |
|
8460
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1579 rc = ngx_http_v3_inc_insert_count(c, st->pint.value); |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1580 if (rc != NGX_OK) { |
|
72f9ff4e0a88
HTTP/3: close QUIC connection with HTTP/QPACK errors when needed.
Roman Arutyunyan <arut@nginx.com>
parents:
8457
diff
changeset
|
1581 return rc; |
| 8226 | 1582 } |
| 1583 | |
| 1584 goto done; | |
| 1585 } | |
| 1586 | |
| 1587 return NGX_AGAIN; | |
| 1588 | |
| 1589 done: | |
| 1590 | |
| 1591 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, | |
| 1592 "http3 parse decoder instruction done"); | |
| 1593 | |
| 1594 st->state = sw_start; | |
|
8456
c9538aef3211
HTTP/3: refactored dynamic table implementation.
Roman Arutyunyan <arut@nginx.com>
parents:
8455
diff
changeset
|
1595 return NGX_AGAIN; |
| 8226 | 1596 } |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1597 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1598 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1599 ngx_int_t |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1600 ngx_http_v3_parse_data(ngx_connection_t *c, ngx_http_v3_parse_data_t *st, |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1601 u_char ch) |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1602 { |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1603 ngx_int_t rc; |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1604 enum { |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1605 sw_start = 0, |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1606 sw_type, |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1607 sw_length, |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1608 sw_skip |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1609 }; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1610 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1611 switch (st->state) { |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1612 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1613 case sw_start: |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1614 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1615 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse data"); |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1616 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1617 st->state = sw_type; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1618 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1619 /* fall through */ |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1620 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1621 case sw_type: |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1622 |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1623 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1624 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1625 return rc; |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1626 } |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1627 |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1628 st->type = st->vlint.value; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1629 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1630 if (st->type == NGX_HTTP_V3_FRAME_HEADERS) { |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1631 /* trailers */ |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1632 goto done; |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1633 } |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1634 |
|
8550
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1635 if (ngx_http_v3_is_v2_frame(st->type)) { |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1636 return NGX_HTTP_V3_ERR_FRAME_UNEXPECTED; |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1637 } |
|
234e9d89ff7f
HTTP/3: reject HTTP/2 frames.
Roman Arutyunyan <arut@nginx.com>
parents:
8549
diff
changeset
|
1638 |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1639 st->state = sw_length; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1640 break; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1641 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1642 case sw_length: |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1643 |
|
8466
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1644 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1645 if (rc != NGX_DONE) { |
|
4fd709540daf
HTTP/3: put ngx_http_v3_parse_varlen_int() return code in variable.
Roman Arutyunyan <arut@nginx.com>
parents:
8465
diff
changeset
|
1646 return rc; |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1647 } |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1648 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1649 st->length = st->vlint.value; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1650 |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1651 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0, |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1652 "http3 parse data type:%ui, len:%ui", |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1653 st->type, st->length); |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1654 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1655 if (st->type != NGX_HTTP_V3_FRAME_DATA && st->length > 0) { |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1656 st->state = sw_skip; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1657 break; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1658 } |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1659 |
|
8549
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1660 st->state = sw_type; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1661 return NGX_OK; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1662 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1663 case sw_skip: |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1664 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1665 if (--st->length == 0) { |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1666 st->state = sw_type; |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1667 } |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1668 |
|
d70a38acaea0
HTTP/3: skip unknown frames on request stream.
Roman Arutyunyan <arut@nginx.com>
parents:
8497
diff
changeset
|
1669 break; |
|
8295
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1670 } |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1671 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1672 return NGX_AGAIN; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1673 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1674 done: |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1675 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1676 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse data done"); |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1677 |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1678 st->state = sw_start; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1679 return NGX_DONE; |
|
5649079a41f4
Parsing HTTP/3 request body.
Roman Arutyunyan <arut@nginx.com>
parents:
8227
diff
changeset
|
1680 } |
|
8772
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1681 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1682 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1683 ngx_int_t |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1684 ngx_http_v3_parse_uni(ngx_connection_t *c, ngx_http_v3_parse_uni_t *st, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1685 u_char ch) |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1686 { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1687 ngx_int_t rc; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1688 enum { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1689 sw_start = 0, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1690 sw_type, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1691 sw_control, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1692 sw_encoder, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1693 sw_decoder, |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1694 sw_unknown |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1695 }; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1696 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1697 switch (st->state) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1698 case sw_start: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1699 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1700 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http3 parse uni"); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1701 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1702 st->state = sw_type; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1703 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1704 /* fall through */ |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1705 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1706 case sw_type: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1707 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1708 rc = ngx_http_v3_parse_varlen_int(c, &st->vlint, ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1709 if (rc != NGX_DONE) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1710 return rc; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1711 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1712 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1713 rc = ngx_http_v3_register_uni_stream(c, st->vlint.value); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1714 if (rc != NGX_OK) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1715 return rc; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1716 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1717 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1718 switch (st->vlint.value) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1719 case NGX_HTTP_V3_STREAM_CONTROL: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1720 st->state = sw_control; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1721 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1722 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1723 case NGX_HTTP_V3_STREAM_ENCODER: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1724 st->state = sw_encoder; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1725 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1726 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1727 case NGX_HTTP_V3_STREAM_DECODER: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1728 st->state = sw_decoder; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1729 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1730 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1731 default: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1732 st->state = sw_unknown; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1733 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1734 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1735 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1736 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1737 case sw_control: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1738 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1739 rc = ngx_http_v3_parse_control(c, &st->u.control, ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1740 if (rc != NGX_OK) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1741 return rc; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1742 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1743 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1744 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1745 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1746 case sw_encoder: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1747 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1748 rc = ngx_http_v3_parse_encoder(c, &st->u.encoder, ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1749 if (rc != NGX_OK) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1750 return rc; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1751 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1752 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1753 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1754 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1755 case sw_decoder: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1756 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1757 rc = ngx_http_v3_parse_decoder(c, &st->u.decoder, ch); |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1758 if (rc != NGX_OK) { |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1759 return rc; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1760 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1761 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1762 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1763 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1764 case sw_unknown: |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1765 break; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1766 } |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1767 |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1768 return NGX_AGAIN; |
|
345370fdd32d
HTTP/3: moved parsing uni stream type to ngx_http_v3_parse.c.
Roman Arutyunyan <arut@nginx.com>
parents:
8771
diff
changeset
|
1769 } |