Debian Codegraph @

third_party/rust/neqo-http3/src/recv_message.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 use std::{
8 cell::RefCell,
9 cmp::min,
10 collections::VecDeque,
11 fmt::{self, Debug, Display, Formatter},
12 rc::Rc,
13 };
14
15 use neqo_common::{header::HeadersExt as _, qdebug, qinfo, qtrace, Header};
16 use neqo_qpack::decoder::QPackDecoder;
17 use neqo_transport::{Connection, StreamId};
18
19 use crate::{
20 frames::{hframe::HFrameType, FrameReader, HFrame, StreamReaderConnectionWrapper},
21 headers_checks::{headers_valid, is_interim},
22 priority::PriorityHandler,
23 push_controller::PushController,
24 qlog, CloseType, Error, Http3StreamInfo, Http3StreamType, HttpRecvStream, HttpRecvStreamEvents,
25 MessageType, Priority, PushId, ReceiveOutput, RecvStream, Res, Stream,
26 };
27
28 pub struct RecvMessageInfo {
29 pub message_type: MessageType,
30 pub stream_type: Http3StreamType,
31 pub stream_id: StreamId,
32 pub first_frame_type: Option<u64>,
33 }
34
35 /*
36 * Response stream state:
37 * WaitingForResponseHeaders : we wait for headers. in this state we can
38 * also get a PUSH_PROMISE frame.
39 * DecodingHeaders : In this step the headers will be decoded. The stream
40 * may be blocked in this state on encoder instructions.
41 * WaitingForData : we got HEADERS, we are waiting for one or more data
42 * frames. In this state we can receive one or more
43 * PUSH_PROMIS frames or a HEADERS frame carrying trailers.
44 * ReadingData : we got a DATA frame, now we letting the app read payload.
45 * From here we will go back to WaitingForData state to wait
46 * for more data frames or to CLosed state
47 * ClosePending : waiting for app to pick up data, after that we can delete
48 * the TransactionClient.
49 * Closed
50 * ExtendedConnect: this request is for a WebTransport session. In this
51 * state RecvMessage will not be treated as a HTTP
52 * stream anymore. It is waiting to be transformed
53 * into WebTransport session or to be closed.
54 */
55 #[derive(Debug)]
56 enum RecvMessageState {
57 WaitingForResponseHeaders { frame_reader: FrameReader },
58 DecodingHeaders { header_block: Vec<u8>, fin: bool },
59 WaitingForData { frame_reader: FrameReader },
60 ReadingData { remaining_data_len: usize },
61 WaitingForFinAfterTrailers { frame_reader: FrameReader },
62 ClosePending, // Close must first be read by application
63 Closed,
64 ExtendedConnect,
65 }
66
67 #[derive(Debug)]
68 struct PushInfo {
69 push_id: PushId,
70 header_block: Vec<u8>,
71 }
72
73 #[derive(Debug)]
74 pub struct RecvMessage {
75 state: RecvMessageState,
76 message_type: MessageType,
77 stream_type: Http3StreamType,
78 qpack_decoder: Rc<RefCell<QPackDecoder>>,
79 conn_events: Box<dyn HttpRecvStreamEvents>,
80 push_handler: Option<Rc<RefCell<PushController>>>,
81 stream_id: StreamId,
82 priority_handler: PriorityHandler,
83 blocked_push_promise: VecDeque<PushInfo>,
84 }
85
86 impl Display for RecvMessage {
87 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
88 write!(f, "RecvMessage stream_id:{}", self.stream_id)
89 }
90 }
91
92 impl RecvMessage {
93 pub fn new(
94 message_info: &RecvMessageInfo,
95 qpack_decoder: Rc<RefCell<QPackDecoder>>,
96 conn_events: Box<dyn HttpRecvStreamEvents>,
97 push_handler: Option<Rc<RefCell<PushController>>>,
98 priority_handler: PriorityHandler,
99 ) -> Self {
100 Self {
101 state: RecvMessageState::WaitingForResponseHeaders {
102 frame_reader: message_info
103 .first_frame_type
104 .map_or_else(FrameReader::new, |frame_type| {
105 FrameReader::new_with_type(HFrameType(frame_type))
106 }),
107 },
108 message_type: message_info.message_type,
109 stream_type: message_info.stream_type,
110 qpack_decoder,
111 conn_events,
112 push_handler,
113 stream_id: message_info.stream_id,
114 priority_handler,
115 blocked_push_promise: VecDeque::new(),
116 }
117 }
118
119 fn handle_headers_frame(&mut self, header_block: Vec<u8>, fin: bool) -> Res<()> {
120 match self.state {
121 RecvMessageState::WaitingForResponseHeaders {..} => {
122 if header_block.is_empty() {
123 return Err(Error::HttpGeneralProtocolStream);
124 }
125 self.state = RecvMessageState::DecodingHeaders { header_block, fin };
126 }
127 RecvMessageState::WaitingForData { ..} => {
128 // TODO implement trailers, for now just ignore them.
129 self.state = RecvMessageState::WaitingForFinAfterTrailers{frame_reader: FrameReader::new()};
130 }
131 RecvMessageState::WaitingForFinAfterTrailers {..} => {
132 return Err(Error::HttpFrameUnexpected);
133 }
134 _ => unreachable!("This functions is only called in WaitingForResponseHeaders | WaitingForData | WaitingForFinAfterTrailers state")
135 }
136 Ok(())
137 }
138
139 fn handle_data_frame(&mut self, len: u64, fin: bool) -> Res<()> {
140 match self.state {
141 RecvMessageState::WaitingForResponseHeaders {..} | RecvMessageState::WaitingForFinAfterTrailers {..} => {
142 return Err(Error::HttpFrameUnexpected);
143 }
144 RecvMessageState::WaitingForData {..} => {
145 if len > 0 {
146 if fin {
147 return Err(Error::HttpFrame);
148 }
149 self.state = RecvMessageState::ReadingData {
150 remaining_data_len: usize::try_from(len).or(Err(Error::HttpFrame))?,
151 };
152 }
153 }
154 _ => unreachable!("This functions is only called in WaitingForResponseHeaders | WaitingForData | WaitingForFinAfterTrailers state")
155 }
156 Ok(())
157 }
158
159 fn add_headers(&mut self, mut headers: Vec<Header>, fin: bool) -> Res<()> {
160 qtrace!("[{self}] Add new headers fin={fin}");
161 let interim = match self.message_type {
162 MessageType::Request => false,
163 MessageType::Response => is_interim(&headers)?,
164 };
165 headers_valid(&headers, self.message_type)?;
166 if self.message_type == MessageType::Response {
167 headers.retain(Header::is_allowed_for_response);
168 }
169
170 if fin && interim {
171 return Err(Error::HttpGeneralProtocolStream);
172 }
173
174 let is_web_transport = self.message_type == MessageType::Request
175 && headers.contains_header(":method", "CONNECT")
176 && headers.contains_header(":protocol", "webtransport");
177 if is_web_transport {
178 self.conn_events
179 .extended_connect_new_session(self.stream_id, headers);
180 } else {
181 self.conn_events
182 .header_ready(self.get_stream_info(), headers, interim, fin);
183 }
184
185 if fin {
186 self.set_closed();
187 } else {
188 self.state = if is_web_transport {
189 self.stream_type = Http3StreamType::ExtendedConnect;
190 RecvMessageState::ExtendedConnect
191 } else if interim {
192 RecvMessageState::WaitingForResponseHeaders {
193 frame_reader: FrameReader::new(),
194 }
195 } else {
196 RecvMessageState::WaitingForData {
197 frame_reader: FrameReader::new(),
198 }
199 };
200 }
201 Ok(())
202 }
203
204 fn set_state_to_close_pending(&mut self, post_readable_event: bool) -> Res<()> {
205 // Stream has received fin. Depending on headers state set header_ready
206 // or data_readable event so that app can pick up the fin.
207 qtrace!(
208 "[{self}] set_state_to_close_pending: state={:?}",
209 self.state
210 );
211
212 match self.state {
213 RecvMessageState::WaitingForResponseHeaders { .. } => {
214 return Err(Error::HttpGeneralProtocolStream);
215 }
216 RecvMessageState::ReadingData { .. } => {}
217 RecvMessageState::WaitingForData { .. }
218 | RecvMessageState::WaitingForFinAfterTrailers { .. } => {
219 if post_readable_event {
220 self.conn_events.data_readable(self.get_stream_info());
221 }
222 }
223 _ => unreachable!("Closing an already closed transaction"),
224 }
225 if !matches!(self.state, RecvMessageState::Closed) {
226 self.state = RecvMessageState::ClosePending;
227 }
228 Ok(())
229 }
230
231 fn handle_push_promise(&mut self, push_id: PushId, header_block: Vec<u8>) -> Res<()> {
232 if self.push_handler.is_none() {
233 return Err(Error::HttpFrameUnexpected);
234 }
235
236 if !self.blocked_push_promise.is_empty() {
237 self.blocked_push_promise.push_back(PushInfo {
238 push_id,
239 header_block,
240 });
241 } else if let Some(headers) = self
242 .qpack_decoder
243 .borrow_mut()
244 .decode_header_block(&header_block, self.stream_id)?
245 {
246 self.push_handler
247 .as_ref()
248 .ok_or(Error::HttpFrameUnexpected)?
249 .borrow_mut()
250 .new_push_promise(push_id, self.stream_id, headers)?;
251 } else {
252 self.blocked_push_promise.push_back(PushInfo {
253 push_id,
254 header_block,
255 });
256 }
257 Ok(())
258 }
259
260 fn receive_internal(&mut self, conn: &mut Connection, post_readable_event: bool) -> Res<()> {
261 loop {
262 qdebug!("[{self}] state={:?}", self.state);
263 match &mut self.state {
264 // In the following 3 states we need to read frames.
265 RecvMessageState::WaitingForResponseHeaders { frame_reader }
266 | RecvMessageState::WaitingForData { frame_reader }
267 | RecvMessageState::WaitingForFinAfterTrailers { frame_reader } => {
268 match frame_reader.receive(&mut StreamReaderConnectionWrapper::new(
269 conn,
270 self.stream_id,
271 ))? {
272 (None, true) => {
273 break self.set_state_to_close_pending(post_readable_event);
274 }
275 (None, false) => break Ok(()),
276 (Some(frame), fin) => {
277 qdebug!(
278 "[{self}] A new frame has been received: {frame:?}; state={:?} fin={fin}", self.state,
279 );
280 match frame {
281 HFrame::Headers { header_block } => {
282 self.handle_headers_frame(header_block, fin)?;
283 }
284 HFrame::Data { len } => self.handle_data_frame(len, fin)?,
285 HFrame::PushPromise {
286 push_id,
287 header_block,
288 } => self.handle_push_promise(push_id, header_block)?,
289 _ => break Err(Error::HttpFrameUnexpected),
290 }
291 if matches!(self.state, RecvMessageState::Closed) {
292 break Ok(());
293 }
294 if fin
295 && !matches!(self.state, RecvMessageState::DecodingHeaders { .. })
296 {
297 break self.set_state_to_close_pending(post_readable_event);
298 }
299 }
300 }
301 }
302 RecvMessageState::DecodingHeaders { header_block, fin } => {
303 if self
304 .qpack_decoder
305 .borrow()
306 .refers_dynamic_table(header_block)?
307 && !self.blocked_push_promise.is_empty()
308 {
309 qinfo!(
310 "[{self}] decoding header is blocked waiting for a push_promise header block"
311 );
312 break Ok(());
313 }
314 let done = *fin;
315 let d_headers = self
316 .qpack_decoder
317 .borrow_mut()
318 .decode_header_block(header_block, self.stream_id)?;
319 if let Some(headers) = d_headers {
320 self.add_headers(headers, done)?;
321 if matches!(
322 self.state,
323 RecvMessageState::Closed | RecvMessageState::ExtendedConnect
324 ) {
325 break Ok(());
326 }
327 } else {
328 qinfo!("[{self}] decoding header is blocked");
329 break Ok(());
330 }
331 }
332 RecvMessageState::ReadingData { .. } => {
333 if post_readable_event {
334 self.conn_events.data_readable(self.get_stream_info());
335 }
336 break Ok(());
337 }
338 RecvMessageState::ClosePending | RecvMessageState::Closed => {
339 panic!("Stream readable after being closed!");
340 }
341 RecvMessageState::ExtendedConnect => {
342 // Ignore read event, this request is waiting to be picked up by a new
343 // WebTransportSession
344 break Ok(());
345 }
346 }
347 }
348 }
349
350 fn set_closed(&mut self) {
351 if !self.blocked_push_promise.is_empty() {
352 self.qpack_decoder
353 .borrow_mut()
354 .cancel_stream(self.stream_id);
355 }
356 self.state = RecvMessageState::Closed;
357 self.conn_events
358 .recv_closed(self.get_stream_info(), CloseType::Done);
359 }
360
361 const fn closing(&self) -> bool {
362 matches!(
363 self.state,
364 RecvMessageState::ClosePending | RecvMessageState::Closed
365 )
366 }
367
368 const fn get_stream_info(&self) -> Http3StreamInfo {
369 Http3StreamInfo::new(self.stream_id, Http3StreamType::Http)
370 }
371 }
372
373 impl Stream for RecvMessage {
374 fn stream_type(&self) -> Http3StreamType {
375 self.stream_type
376 }
377 }
378
379 impl RecvStream for RecvMessage {
380 fn receive(&mut self, conn: &mut Connection) -> Res<(ReceiveOutput, bool)> {
381 self.receive_internal(conn, true)?;
382 Ok((
383 ReceiveOutput::NoOutput,
384 matches!(self.state, RecvMessageState::Closed),
385 ))
386 }
387
388 fn reset(&mut self, close_type: CloseType) -> Res<()> {
389 if !self.closing() || !self.blocked_push_promise.is_empty() {
390 self.qpack_decoder
391 .borrow_mut()
392 .cancel_stream(self.stream_id);
393 }
394 self.conn_events
395 .recv_closed(self.get_stream_info(), close_type);
396 self.state = RecvMessageState::Closed;
397 Ok(())
398 }
399
400 fn read_data(&mut self, conn: &mut Connection, buf: &mut [u8]) -> Res<(usize, bool)> {
401 let mut written = 0;
402 loop {
403 match self.state {
404 RecvMessageState::ReadingData {
405 ref mut remaining_data_len,
406 } => {
407 let to_read = min(*remaining_data_len, buf.len() - written);
408 let (amount, fin) = conn
409 .stream_recv(self.stream_id, &mut buf[written..written + to_read])
410 .map_err(|e| Error::map_stream_recv_errors(&Error::from(e)))?;
411 qlog::h3_data_moved_up(conn.qlog_mut(), self.stream_id, amount);
412
413 debug_assert!(amount <= to_read);
414 *remaining_data_len -= amount;
415 written += amount;
416
417 if fin {
418 if *remaining_data_len > 0 {
419 return Err(Error::HttpFrame);
420 }
421 self.set_closed();
422 break Ok((written, fin));
423 } else if *remaining_data_len == 0 {
424 self.state = RecvMessageState::WaitingForData {
425 frame_reader: FrameReader::new(),
426 };
427 self.receive_internal(conn, false)?;
428 } else {
429 break Ok((written, false));
430 }
431 }
432 RecvMessageState::ClosePending => {
433 self.set_closed();
434 break Ok((written, true));
435 }
436 _ => break Ok((written, false)),
437 }
438 }
439 }
440
441 fn http_stream(&mut self) -> Option<&mut dyn HttpRecvStream> {
442 Some(self)
443 }
444 }
445
446 impl HttpRecvStream for RecvMessage {
447 fn header_unblocked(&mut self, conn: &mut Connection) -> Res<(ReceiveOutput, bool)> {
448 while let Some(p) = self.blocked_push_promise.front() {
449 if let Some(headers) = self
450 .qpack_decoder
451 .borrow_mut()
452 .decode_header_block(&p.header_block, self.stream_id)?
453 {
454 self.push_handler
455 .as_ref()
456 .ok_or(Error::HttpFrameUnexpected)?
457 .borrow_mut()
458 .new_push_promise(p.push_id, self.stream_id, headers)?;
459 self.blocked_push_promise.pop_front();
460 } else {
461 return Ok((ReceiveOutput::NoOutput, false));
462 }
463 }
464
465 self.receive(conn)
466 }
467
468 fn maybe_update_priority(&mut self, priority: Priority) -> Res<bool> {
469 Ok(self.priority_handler.maybe_update_priority(priority))
470 }
471
472 fn priority_update_frame(&mut self) -> Option<HFrame> {
473 self.priority_handler.maybe_encode_frame(self.stream_id)
474 }
475
476 fn priority_update_sent(&mut self) -> Res<()> {
477 self.priority_handler.priority_update_sent();
478 Ok(())
479 }
480
481 fn set_new_listener(&mut self, conn_events: Box<dyn HttpRecvStreamEvents>) {
482 self.state = RecvMessageState::WaitingForData {
483 frame_reader: FrameReader::new(),
484 };
485 self.conn_events = conn_events;
486 }
487
488 fn extended_connect_wait_for_response(&self) -> bool {
489 matches!(self.state, RecvMessageState::ExtendedConnect)
490 }
491 }