Debian Codegraph @

third_party/rust/neqo-http3/src/connection_client.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 fmt::{self, Debug, Display, Formatter},
10 iter,
11 net::SocketAddr,
12 rc::Rc,
13 time::Instant,
14 };
15
16 use neqo_common::{
17 event::Provider as EventProvider, hex, hex_with_len, qdebug, qinfo, qlog::NeqoQlog, qtrace,
18 Datagram, Decoder, Encoder, Header, MessageType, Role,
19 };
20 use neqo_crypto::{agent::CertificateInfo, AuthenticationStatus, ResumptionToken, SecretAgentInfo};
21 use neqo_qpack::Stats as QpackStats;
22 use neqo_transport::{
23 streams::SendOrder, AppError, Connection, ConnectionEvent, ConnectionId, ConnectionIdGenerator,
24 DatagramTracking, Output, RecvStreamStats, SendStreamStats, Stats as TransportStats, StreamId,
25 StreamType, Version, ZeroRttState,
26 };
27
28 use crate::{
29 client_events::{Http3ClientEvent, Http3ClientEvents},
30 connection::{Http3Connection, Http3State, RequestDescription},
31 frames::HFrame,
32 push_controller::{PushController, RecvPushEvents},
33 recv_message::{RecvMessage, RecvMessageInfo},
34 request_target::AsRequestTarget,
35 settings::HSettings,
36 Error, Http3Parameters, Http3StreamType, NewStreamType, Priority, PriorityHandler, PushId,
37 ReceiveOutput, Res,
38 };
39
40 // This is used for filtering send_streams and recv_Streams with a stream_ids greater than or equal
41 // a given id. Only the same type (bidirectional or unidirectional) streams are filtered.
42 fn id_gte<U>(base: StreamId) -> impl FnMut((&StreamId, &U)) -> Option<StreamId> + 'static
43 where
44 U: ?Sized,
45 {
46 move |(id, _)| (*id >= base && !(id.is_bidi() ^ base.is_bidi())).then_some(*id)
47 }
48
49 const fn alpn_from_quic_version(version: Version) -> &'static str {
50 match version {
51 Version::Version2 | Version::Version1 => "h3",
52 #[cfg(feature = "draft-29")]
53 Version::Draft29 => "h3-29",
54 }
55 }
56
57 /// # The HTTP/3 client API
58 ///
59 /// This module implements the HTTP/3 client API. The main implementation of the protocol is in
60 /// [connection.rs](https://github.com/mozilla/neqo/blob/main/neqo-http3/src/connection.rs) which
61 /// implements common behavior for the client-side and the server-side. `Http3Client` structure
62 /// implements the public API and set of functions that differ between the client and the server.
63 ///
64 /// The API is used for:
65 /// - create and close an endpoint:
66 /// - [`Http3Client::new`]
67 /// - [`Http3Client::new_with_conn`]
68 /// - [`Http3Client::close`]
69 /// - configuring an endpoint:
70 /// - [`Http3Client::authenticated`]
71 /// - [`Http3Client::enable_ech`]
72 /// - [`Http3Client::enable_resumption`]
73 /// - [`Http3Client::initiate_key_update`]
74 /// - [`Http3Client::set_qlog`]
75 /// - retrieving information about a connection:
76 /// - [`Http3Client::peer_certificate`]
77 /// - [`Http3Client::qpack_decoder_stats`]
78 /// - [`Http3Client::qpack_encoder_stats`]
79 /// - [`Http3Client::transport_stats`]
80 /// - [`Http3Client::state`]
81 /// - [`Http3Client::take_resumption_token`]
82 /// - [`Http3Client::tls_info`]
83 /// - driving HTTP/3 session:
84 /// - [`Http3Client::process_output`]
85 /// - [`Http3Client::process_input`]
86 /// - [`Http3Client::process`]
87 /// - create requests, send/receive data, and cancel requests:
88 /// - [`Http3Client::fetch`]
89 /// - [`Http3Client::send_data`]
90 /// - [`Http3Client::read_data`]
91 /// - [`Http3Client::stream_close_send`]
92 /// - [`Http3Client::cancel_fetch`]
93 /// - [`Http3Client::stream_reset_send`]
94 /// - [`Http3Client::stream_stop_sending`]
95 /// - [`Http3Client::set_stream_max_data`]
96 /// - priority feature:
97 /// - [`Http3Client::priority_update`]
98 /// - `WebTransport` feature:
99 /// - [`Http3Client::webtransport_create_session`]
100 /// - [`Http3Client::webtransport_close_session`]
101 /// - [`Http3Client::webtransport_create_stream`]
102 /// - [`Http3Client::webtransport_enabled`]
103 ///
104 /// ## Examples
105 ///
106 /// ### Fetching a resource
107 ///
108 /// ```ignore
109 /// let mut client = Http3Client::new(...);
110 ///
111 /// // Perform a handshake
112 /// ...
113 ///
114 /// let req = client
115 /// .fetch(
116 /// Instant::now(),
117 /// "GET",
118 /// &("https", "something.com", "/"),
119 /// &[Header::new("example1", "value1"), Header::new("example1", "value2")],
120 /// Priority::default(),
121 /// )
122 /// .unwrap();
123 ///
124 /// client.stream_close_send(req).unwrap();
125 ///
126 /// loop {
127 /// // exchange packets
128 /// ...
129 ///
130 /// while let Some(event) = client.next_event() {
131 /// match event {
132 /// Http3ClientEvent::HeaderReady { stream_id, headers, interim, fin } => {
133 /// println!("New response headers received for stream {:?} [fin={?}, interim={:?}]: {:?}",
134 /// stream_id,
135 /// fin,
136 /// interim,
137 /// headers,
138 /// );
139 /// }
140 /// Http3ClientEvent::DataReadable { stream_id } => {
141 /// println!("New data available on stream {stream_id}");
142 /// let mut buf = [0; 100];
143 /// let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
144 /// println!("Read {:?} bytes from stream {:?} [fin={?}]",
145 /// amount,
146 /// stream_id,
147 /// fin,
148 /// );
149 /// }
150 /// _ => {
151 /// println!("Unhandled event {:?}", event);
152 /// }
153 /// }
154 /// }
155 /// }
156 /// ```
157 ///
158 /// ### Creating a `WebTransport` session
159 ///
160 /// ```ignore
161 /// let mut client = Http3Client::new(...);
162 ///
163 /// // Perform a handshake
164 /// ...
165 ///
166 /// // Create a session
167 /// let wt_session_id = client
168 /// .webtransport_create_session(now(), &("https", "something.com", "/"), &[])
169 /// .unwrap();
170 ///
171 /// loop {
172 /// // exchange packets
173 /// ...
174 ///
175 /// while let Some(event) = client.next_event() {
176 /// match event {
177 /// Http3ClientEvent::WebTransport(WebTransportEvent::Session{
178 /// stream_id,
179 /// status,
180 /// ..
181 /// }) => {
182 /// println!("The response from the server: WebTransport session ID {:?} status={:?}",
183 /// stream_id,
184 /// status,
185 /// );
186 /// }
187 /// _ => {
188 /// println!("Unhandled event {:?}", event);
189 /// }
190 /// }
191 /// }
192 /// }
193 /// ```
194 ///
195 /// ### `WebTransport`: create a stream, send and receive data on the stream
196 ///
197 /// ```ignore
198 /// const BUF_CLIENT: &[u8] = &[0; 10];
199 /// // wt_session_id is the session ID of a newly created WebTransport session, see the example above.
200 ///
201 /// // create a stream
202 /// let wt_stream_id = client
203 /// .webtransport_create_stream(wt_session_id, StreamType::BiDi)
204 /// .unwrap();
205 ///
206 /// // send data
207 /// let data_sent = client.send_data(wt_stream_id, BUF_CLIENT).unwrap();
208 /// assert_eq!(data_sent, BUF_CLIENT.len());
209 ///
210 /// // close stream for sending
211 /// client.stream_close_send(wt_stream_id).unwrap();
212 ///
213 /// // wait for data from the server
214 /// loop {
215 /// // exchange packets
216 /// ...
217 ///
218 /// while let Some(event) = client.next_event() {
219 /// match event {
220 /// Http3ClientEvent::DataReadable{ stream_id } => {
221 /// println!("Data received form the server on WebTransport stream ID {:?}",
222 /// stream_id,
223 /// );
224 /// let mut buf = [0; 100];
225 /// let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
226 /// println!("Read {:?} bytes from stream {:?} [fin={?}]",
227 /// amount,
228 /// stream_id,
229 /// fin,
230 /// );
231 /// }
232 /// _ => {
233 /// println!("Unhandled event {:?}", event);
234 /// }
235 /// }
236 /// }
237 /// }
238 /// ```
239 ///
240 /// ### `WebTransport`: receive a new stream form the server
241 ///
242 /// ```ignore
243 /// // wt_session_id is the session ID of a newly created WebTransport session, see the example above.
244 ///
245 /// // wait for a new stream from the server
246 /// loop {
247 /// // exchange packets
248 /// ...
249 ///
250 /// while let Some(event) = client.next_event() {
251 /// match event {
252 /// Http3ClientEvent::WebTransport(WebTransportEvent::NewStream {
253 /// stream_id,
254 /// session_id,
255 /// }) => {
256 /// println!("New stream received on session{:?}, stream id={:?} stream type={:?}",
257 /// session_id.stream_id(),
258 /// stream_id.stream_id(),
259 /// stream_id.stream_type()
260 /// );
261 /// }
262 /// Http3ClientEvent::DataReadable{ stream_id } => {
263 /// println!("Data received form the server on WebTransport stream ID {:?}",
264 /// stream_id,
265 /// );
266 /// let mut buf = [0; 100];
267 /// let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
268 /// println!("Read {:?} bytes from stream {:?} [fin={:?}]",
269 /// amount,
270 /// stream_id,
271 /// fin,
272 /// );
273 /// }
274 /// _ => {
275 /// println!("Unhandled event {:?}", event);
276 /// }
277 /// }
278 /// }
279 /// }
280 /// ```
281 pub struct Http3Client {
282 conn: Connection,
283 base_handler: Http3Connection,
284 events: Http3ClientEvents,
285 push_handler: Rc<RefCell<PushController>>,
286 }
287
288 impl Display for Http3Client {
289 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
290 write!(f, "Http3 client")
291 }
292 }
293
294 impl Http3Client {
295 /// # Errors
296 ///
297 /// Making a `neqo-transport::connection` may produce an error. This can only be a crypto error
298 /// if the crypto context can't be created or configured.
299 pub fn new(
300 server_name: impl Into<String>,
301 cid_manager: Rc<RefCell<dyn ConnectionIdGenerator>>,
302 local_addr: SocketAddr,
303 remote_addr: SocketAddr,
304 http3_parameters: Http3Parameters,
305 now: Instant,
306 ) -> Res<Self> {
307 Ok(Self::new_with_conn(
308 Connection::new_client(
309 server_name,
310 &[alpn_from_quic_version(
311 http3_parameters
312 .get_connection_parameters()
313 .get_versions()
314 .initial(),
315 )],
316 cid_manager,
317 local_addr,
318 remote_addr,
319 http3_parameters.get_connection_parameters().clone(),
320 now,
321 )?,
322 http3_parameters,
323 ))
324 }
325
326 /// This is a similar function to `new`. In this case, `neqo-transport::connection` has been
327 /// already created.
328 ///
329 /// It is recommended to use `new` instead.
330 #[must_use]
331 pub fn new_with_conn(c: Connection, http3_parameters: Http3Parameters) -> Self {
332 let events = Http3ClientEvents::default();
333 let webtransport = http3_parameters.get_webtransport();
334 let push_streams = http3_parameters.get_max_concurrent_push_streams();
335 let mut base_handler = Http3Connection::new(http3_parameters, Role::Client);
336 if webtransport {
337 base_handler.set_features_listener(events.clone());
338 }
339 Self {
340 conn: c,
341 events: events.clone(),
342 push_handler: Rc::new(RefCell::new(PushController::new(push_streams, events))),
343 base_handler,
344 }
345 }
346
347 #[must_use]
348 pub const fn role(&self) -> Role {
349 self.conn.role()
350 }
351
352 /// The function returns the current state of the connection.
353 #[must_use]
354 pub fn state(&self) -> Http3State {
355 self.base_handler.state().clone()
356 }
357
358 #[must_use]
359 pub fn tls_info(&self) -> Option<&SecretAgentInfo> {
360 self.conn.tls_info()
361 }
362
363 /// Get the peer's certificate.
364 #[must_use]
365 pub fn peer_certificate(&self) -> Option<CertificateInfo> {
366 self.conn.peer_certificate()
367 }
368
369 /// This called when peer certificates have been verified.
370 ///
371 /// `Http3ClientEvent::AuthenticationNeeded` event is emitted when peer’s certificates are
372 /// available and need to be verified. When the verification is completed this function is
373 /// called. To inform HTTP/3 session of the verification results.
374 pub fn authenticated(&mut self, status: AuthenticationStatus, now: Instant) {
375 self.conn.authenticated(status, now);
376 }
377
378 pub fn set_qlog(&mut self, qlog: NeqoQlog) {
379 self.conn.set_qlog(qlog);
380 }
381
382 /// Enable encrypted client hello (ECH).
383 ///
384 /// # Errors
385 ///
386 /// Fails when the configuration provided is bad.
387 pub fn enable_ech(&mut self, ech_config_list: impl AsRef<[u8]>) -> Res<()> {
388 self.conn.client_enable_ech(ech_config_list)?;
389 Ok(())
390 }
391
392 /// Get the connection id, which is useful for disambiguating connections to
393 /// the same origin.
394 ///
395 /// # Panics
396 ///
397 /// Never, because clients always have this field.
398 #[must_use]
399 pub fn connection_id(&self) -> &ConnectionId {
400 self.conn.odcid().expect("Client always has odcid")
401 }
402
403 fn encode_resumption_token(&self, token: &ResumptionToken) -> Option<ResumptionToken> {
404 self.base_handler.get_settings().map(|settings| {
405 let mut enc = Encoder::default();
406 settings.encode_frame_contents(&mut enc);
407 enc.encode(token.as_ref());
408 ResumptionToken::new(enc.into(), token.expiration_time())
409 })
410 }
411
412 /// The correct way to obtain a resumption token is to wait for the
413 /// `Http3ClientEvent::ResumptionToken` event. To emit the event we are waiting for a
414 /// resumption token and a `NEW_TOKEN` frame to arrive. Some servers don't send `NEW_TOKEN`
415 /// frames and in this case, we wait for 3xPTO before emitting an event. This is especially a
416 /// problem for short-lived connections, where the connection is closed before any events are
417 /// released. This function retrieves the token, without waiting for a `NEW_TOKEN` frame to
418 /// arrive.
419 ///
420 /// In addition to the token, HTTP/3 settings are encoded into the token before giving it to
421 /// the application(`encode_resumption_token`). When the resumption token is supplied to a new
422 /// connection the HTTP/3 setting will be decoded and used until the setting are received from
423 /// the server.
424 pub fn take_resumption_token(&mut self, now: Instant) -> Option<ResumptionToken> {
425 let t = self.conn.take_resumption_token(now)?;
426 self.encode_resumption_token(&t)
427 }
428
429 /// This may be call if an application has a resumption token. This must be called before
430 /// connection starts.
431 ///
432 /// The resumption token also contains encoded HTTP/3 settings. The settings will be decoded
433 /// and used until the setting are received from the server.
434 ///
435 /// # Errors
436 ///
437 /// An error is return if token cannot be decoded or a connection is is a wrong state.
438 ///
439 /// # Panics
440 ///
441 /// On closing if the base handler can't handle it (debug only).
442 pub fn enable_resumption(&mut self, now: Instant, token: impl AsRef<[u8]>) -> Res<()> {
443 if self.base_handler.state() != &Http3State::Initializing {
444 return Err(Error::InvalidState);
445 }
446 let mut dec = Decoder::from(token.as_ref());
447 let Some(settings_slice) = dec.decode_vvec() else {
448 return Err(Error::InvalidResumptionToken);
449 };
450 qtrace!("[{self}] settings {}", hex_with_len(settings_slice));
451 let mut dec_settings = Decoder::from(settings_slice);
452 let mut settings = HSettings::default();
453 Error::map_error(
454 settings.decode_frame_contents(&mut dec_settings),
455 Error::InvalidResumptionToken,
456 )?;
457 let tok = dec.decode_remainder();
458 qtrace!("[{self}] Transport token {}", hex(tok));
459 self.conn.enable_resumption(now, tok)?;
460 if self.conn.state().closed() {
461 let state = self.conn.state().clone();
462 let res = self
463 .base_handler
464 .handle_state_change(&mut self.conn, &state);
465 debug_assert_eq!(Ok(true), res);
466 return Err(Error::FatalError);
467 }
468 if self.conn.zero_rtt_state() == ZeroRttState::Sending {
469 self.base_handler
470 .set_0rtt_settings(&mut self.conn, settings)?;
471 self.events
472 .connection_state_change(self.base_handler.state().clone());
473 self.push_handler
474 .borrow_mut()
475 .maybe_send_max_push_id_frame(&mut self.base_handler);
476 }
477 Ok(())
478 }
479
480 /// This is call to close a connection.
481 pub fn close<S>(&mut self, now: Instant, error: AppError, msg: S)
482 where
483 S: AsRef<str> + Display,
484 {
485 qinfo!("[{self}] Close the connection error={error} msg={msg}");
486 if !matches!(
487 self.base_handler.state(),
488 Http3State::Closing(_) | Http3State::Closed(_)
489 ) {
490 self.push_handler.borrow_mut().clear();
491 self.conn.close(now, error, msg);
492 self.base_handler.close(error);
493 self.events
494 .connection_state_change(self.base_handler.state().clone());
495 }
496 }
497
498 /// Attempt to force a key update.
499 ///
500 /// # Errors
501 ///
502 /// If the connection isn't confirmed, or there is an outstanding key update, this
503 /// returns `Err(Error::TransportError(neqo_transport::Error::KeyUpdateBlocked))`.
504 pub fn initiate_key_update(&mut self) -> Res<()> {
505 self.conn.initiate_key_update()?;
506 Ok(())
507 }
508
509 // API: Request/response
510
511 /// The function fetches a resource using `method`, `target` and `headers`. A response body
512 /// may be added by calling `send_data`. `stream_close_send` must be sent to finish the request
513 /// even if request data are not sent.
514 ///
515 /// # Errors
516 ///
517 /// If a new stream cannot be created an error will be return.
518 ///
519 /// # Panics
520 ///
521 /// `SendMessage` implements `http_stream` so it will not panic.
522 pub fn fetch<'x, 't: 'x, T>(
523 &mut self,
524 now: Instant,
525 method: &'t str,
526 target: &'t T,
527 headers: &'t [Header],
528 priority: Priority,
529 ) -> Res<StreamId>
530 where
531 T: AsRequestTarget<'x> + ?Sized + Debug,
532 {
533 let output = self.base_handler.fetch(
534 &mut self.conn,
535 Box::new(self.events.clone()),
536 Box::new(self.events.clone()),
537 Some(Rc::clone(&self.push_handler)),
538 &RequestDescription {
539 method,
540 connect_type: None,
541 target,
542 headers,
543 priority,
544 },
545 );
546 if let Err(e) = &output {
547 if e.connection_error() {
548 self.close(now, e.code(), "");
549 }
550 }
551 output
552 }
553
554 /// Send an [`PRIORITY_UPDATE`-frame][1] on next `Http3Client::process_output()` call.
555 /// Returns if the priority got changed.
556 ///
557 /// # Errors
558 ///
559 /// `InvalidStreamId` if the stream does not exist
560 ///
561 /// [1]: https://datatracker.ietf.org/doc/html/draft-kazuho-httpbis-priority-04#section-5.2
562 pub fn priority_update(&mut self, stream_id: StreamId, priority: Priority) -> Res<bool> {
563 self.base_handler.queue_update_priority(stream_id, priority)
564 }
565
566 /// An application may cancel a stream(request).
567 /// Both sides, the receiving and sending side, sending and receiving side, will be closed.
568 ///
569 /// # Errors
570 ///
571 /// An error will be return if a stream does not exist.
572 pub fn cancel_fetch(&mut self, stream_id: StreamId, error: AppError) -> Res<()> {
573 qinfo!("[{self}] reset_stream {stream_id} error={error}");
574 self.base_handler
575 .cancel_fetch(stream_id, error, &mut self.conn)
576 }
577
578 /// This is call when application is done sending a request.
579 ///
580 /// # Errors
581 ///
582 /// An error will be return if stream does not exist.
583 pub fn stream_close_send(&mut self, stream_id: StreamId) -> Res<()> {
584 qdebug!("[{self}] Close sending side stream={stream_id}");
585 self.base_handler
586 .stream_close_send(&mut self.conn, stream_id)
587 }
588
589 /// # Errors
590 ///
591 /// An error will be return if a stream does not exist.
592 pub fn stream_reset_send(&mut self, stream_id: StreamId, error: AppError) -> Res<()> {
593 qinfo!("[{self}] stream_reset_send {stream_id} error={error}");
594 self.base_handler
595 .stream_reset_send(&mut self.conn, stream_id, error)
596 }
597
598 /// # Errors
599 ///
600 /// An error will be return if a stream does not exist.
601 pub fn stream_stop_sending(&mut self, stream_id: StreamId, error: AppError) -> Res<()> {
602 qinfo!("[{self}] stream_stop_sending {stream_id} error={error}");
603 self.base_handler
604 .stream_stop_sending(&mut self.conn, stream_id, error)
605 }
606
607 /// This function is used for regular HTTP requests and `WebTransport` streams.
608 /// In the case of regular HTTP requests, the request body is supplied using this function, and
609 /// headers are supplied through the `fetch` function.
610 ///
611 /// # Errors
612 ///
613 /// `InvalidStreamId` if the stream does not exist,
614 /// `AlreadyClosed` if the stream has already been closed.
615 /// `TransportStreamDoesNotExist` if the transport stream does not exist (this may happen if
616 /// `process_output` has not been called when needed, and HTTP3 layer has not picked up the
617 /// info that the stream has been closed.) `InvalidInput` if an empty buffer has been
618 /// supplied.
619 pub fn send_data(&mut self, stream_id: StreamId, buf: &[u8]) -> Res<usize> {
620 qinfo!(
621 "[{self}] end_data from stream {stream_id} sending {} bytes",
622 buf.len()
623 );
624 self.base_handler
625 .send_streams_mut()
626 .get_mut(&stream_id)
627 .ok_or(Error::InvalidStreamId)?
628 .send_data(&mut self.conn, buf)
629 }
630
631 /// Response data are read directly into a buffer supplied as a parameter of this function to
632 /// avoid copying data.
633 ///
634 /// # Errors
635 ///
636 /// It returns an error if a stream does not exist or an error happen while reading a stream,
637 /// e.g. early close, protocol error, etc.
638 pub fn read_data(
639 &mut self,
640 now: Instant,
641 stream_id: StreamId,
642 buf: &mut [u8],
643 ) -> Res<(usize, bool)> {
644 qdebug!("[{self}] read_data from stream {stream_id}");
645 let res = self.base_handler.read_data(&mut self.conn, stream_id, buf);
646 if let Err(e) = &res {
647 if e.connection_error() {
648 self.close(now, e.code(), "");
649 }
650 }
651 res
652 }
653
654 // API: Push streams
655
656 /// Cancel a push
657 ///
658 /// # Errors
659 ///
660 /// `InvalidStreamId` if the stream does not exist.
661 pub fn cancel_push(&mut self, push_id: PushId) -> Res<()> {
662 self.push_handler
663 .borrow_mut()
664 .cancel(push_id, &mut self.conn, &mut self.base_handler)
665 }
666
667 /// Push response data are read directly into a buffer supplied as a parameter of this function
668 /// to avoid copying data.
669 ///
670 /// # Errors
671 ///
672 /// It returns an error if a stream does not exist(`InvalidStreamId`) or an error has happened
673 /// while reading a stream, e.g. early close, protocol error, etc.
674 pub fn push_read_data(
675 &mut self,
676 now: Instant,
677 push_id: PushId,
678 buf: &mut [u8],
679 ) -> Res<(usize, bool)> {
680 let stream_id = self
681 .push_handler
682 .borrow_mut()
683 .get_active_stream_id(push_id)
684 .ok_or(Error::InvalidStreamId)?;
685 self.conn.stream_keep_alive(stream_id, true)?;
686 self.read_data(now, stream_id, buf)
687 }
688
689 // API WebTransport
690 //
691 /// # Errors
692 ///
693 /// If `WebTransport` cannot be created, e.g. the `WebTransport` support is
694 /// not negotiated or the HTTP/3 connection is closed.
695 pub fn webtransport_create_session<'x, 't: 'x, T>(
696 &mut self,
697 now: Instant,
698 target: &'t T,
699 headers: &'t [Header],
700 ) -> Res<StreamId>
701 where
702 T: AsRequestTarget<'x> + ?Sized + Debug,
703 {
704 let output = self.base_handler.webtransport_create_session(
705 &mut self.conn,
706 Box::new(self.events.clone()),
707 target,
708 headers,
709 );
710
711 if let Err(e) = &output {
712 if e.connection_error() {
713 self.close(now, e.code(), "");
714 }
715 }
716 output
717 }
718
719 /// Close `WebTransport` cleanly
720 ///
721 /// # Errors
722 ///
723 /// `InvalidStreamId` if the stream does not exist,
724 /// `TransportStreamDoesNotExist` if the transport stream does not exist (this may happen if
725 /// `process_output` has not been called when needed, and HTTP3 layer has not picked up the
726 /// info that the stream has been closed.) `InvalidInput` if an empty buffer has been
727 /// supplied.
728 pub fn webtransport_close_session(
729 &mut self,
730 session_id: StreamId,
731 error: u32,
732 message: &str,
733 ) -> Res<()> {
734 self.base_handler
735 .webtransport_close_session(&mut self.conn, session_id, error, message)
736 }
737
738 /// # Errors
739 ///
740 /// This may return an error if the particular session does not exist
741 /// or the connection is not in the active state.
742 pub fn webtransport_create_stream(
743 &mut self,
744 session_id: StreamId,
745 stream_type: StreamType,
746 ) -> Res<StreamId> {
747 self.base_handler.webtransport_create_stream_local(
748 &mut self.conn,
749 session_id,
750 stream_type,
751 Box::new(self.events.clone()),
752 Box::new(self.events.clone()),
753 )
754 }
755
756 /// Send `WebTransport` datagram.
757 ///
758 /// # Errors
759 ///
760 /// It may return `InvalidStreamId` if a stream does not exist anymore.
761 /// The function returns `TooMuchData` if the supply buffer is bigger than
762 /// the allowed remote datagram size.
763 pub fn webtransport_send_datagram(
764 &mut self,
765 session_id: StreamId,
766 buf: &[u8],
767 id: impl Into<DatagramTracking>,
768 ) -> Res<()> {
769 qtrace!("webtransport_send_datagram session:{session_id:?}");
770 self.base_handler
771 .webtransport_send_datagram(session_id, &mut self.conn, buf, id)
772 }
773
774 /// Returns the current max size of a datagram that can fit into a packet.
775 /// The value will change over time depending on the encoded size of the
776 /// packet number, ack frames, etc.
777 ///
778 /// # Errors
779 ///
780 /// The function returns `NotAvailable` if datagrams are not enabled.
781 ///
782 /// # Panics
783 ///
784 /// This cannot panic. The max varint length is 8.
785 pub fn webtransport_max_datagram_size(&self, session_id: StreamId) -> Res<u64> {
786 Ok(self.conn.max_datagram_size()?
787 - u64::try_from(Encoder::varint_len(session_id.as_u64()))
788 .map_err(|_| Error::Internal)?)
789 }
790
791 /// Sets the `SendOrder` for a given stream
792 ///
793 /// # Errors
794 ///
795 /// It may return `InvalidStreamId` if a stream does not exist anymore.
796 ///
797 /// # Panics
798 ///
799 /// This cannot panic.
800 pub fn webtransport_set_sendorder(
801 &mut self,
802 stream_id: StreamId,
803 sendorder: Option<SendOrder>,
804 ) -> Res<()> {
805 Http3Connection::stream_set_sendorder(&mut self.conn, stream_id, sendorder)
806 }
807
808 /// Sets the `Fairness` for a given stream
809 ///
810 /// # Errors
811 ///
812 /// It may return `InvalidStreamId` if a stream does not exist anymore.
813 pub fn webtransport_set_fairness(&mut self, stream_id: StreamId, fairness: bool) -> Res<()> {
814 Http3Connection::stream_set_fairness(&mut self.conn, stream_id, fairness)
815 }
816
817 /// Returns the current `SendStreamStats` of a `WebTransportSendStream`.
818 ///
819 /// # Errors
820 ///
821 /// `InvalidStreamId` if the stream does not exist.
822 pub fn webtransport_send_stream_stats(&mut self, stream_id: StreamId) -> Res<SendStreamStats> {
823 self.base_handler
824 .send_streams_mut()
825 .get_mut(&stream_id)
826 .ok_or(Error::InvalidStreamId)?
827 .stats(&mut self.conn)
828 }
829
830 /// Returns the current `RecvStreamStats` of a `WebTransportRecvStream`.
831 ///
832 /// # Errors
833 ///
834 /// `InvalidStreamId` if the stream does not exist.
835 pub fn webtransport_recv_stream_stats(&mut self, stream_id: StreamId) -> Res<RecvStreamStats> {
836 self.base_handler
837 .recv_streams_mut()
838 .get_mut(&stream_id)
839 .ok_or(Error::InvalidStreamId)?
840 .stats(&mut self.conn)
841 }
842
843 /// This function combines `process_input` and `process_output` function.
844 pub fn process(
845 &mut self,
846 dgram: Option<Datagram<impl AsRef<[u8]> + AsMut<[u8]>>>,
847 now: Instant,
848 ) -> Output {
849 qtrace!("[{self}] Process");
850 if let Some(d) = dgram {
851 self.process_input(d, now);
852 }
853 self.process_output(now)
854 }
855
856 /// The function should be called when there is a new UDP packet available. The function will
857 /// handle the packet payload.
858 ///
859 /// First, the payload will be handled by the QUIC layer. Afterward, `process_http3` will be
860 /// called to handle new [`ConnectionEvent`][1]s.
861 ///
862 /// After this function is called `process_output` should be called to check whether new
863 /// packets need to be sent or if a timer needs to be updated.
864 ///
865 /// [1]: ../neqo_transport/enum.ConnectionEvent.html
866 pub fn process_input(&mut self, dgram: Datagram<impl AsRef<[u8]> + AsMut<[u8]>>, now: Instant) {
867 self.process_multiple_input(iter::once(dgram), now);
868 }
869
870 pub fn process_multiple_input(
871 &mut self,
872 dgrams: impl IntoIterator<Item = Datagram<impl AsRef<[u8]> + AsMut<[u8]>>>,
873 now: Instant,
874 ) {
875 let mut dgrams = dgrams.into_iter().peekable();
876 qtrace!("[{self}] Process multiple datagrams");
877 if dgrams.peek().is_none() {
878 return;
879 }
880 self.conn.process_multiple_input(dgrams, now);
881 self.process_http3(now);
882 }
883
884 /// Process HTTP3 layer.
885 /// When `process_output`, `process_input`, or `process` is called we must call this function
886 /// as well. The functions calls `Http3Client::check_connection_events` to handle events from
887 /// the QUC layer and calls `Http3Connection::process_sending` to ensure that HTTP/3 layer
888 /// data, e.g. control frames, are sent.
889 fn process_http3(&mut self, now: Instant) {
890 qtrace!("[{self}] Process http3 internal");
891 match self.base_handler.state() {
892 Http3State::ZeroRtt | Http3State::Connected | Http3State::GoingAway(..) => {
893 let res = self.check_connection_events();
894 if self.check_result(now, &res) {
895 return;
896 }
897 self.push_handler
898 .borrow_mut()
899 .maybe_send_max_push_id_frame(&mut self.base_handler);
900 let res = self.base_handler.process_sending(&mut self.conn);
901 self.check_result(now, &res);
902 }
903 Http3State::Closed { .. } => {}
904 _ => {
905 let res = self.check_connection_events();
906 _ = self.check_result(now, &res);
907 }
908 }
909 }
910
911 /// The function should be called to check if there is a new UDP packet to be sent. It should
912 /// be called after a new packet is received and processed and after a timer expires (QUIC
913 /// needs timers to handle events like PTO detection and timers are not implemented by the neqo
914 /// library, but instead must be driven by the application).
915 ///
916 /// `process_output` can return:
917 /// - a [`Output::Datagram(Datagram)`][1]: data that should be sent as a UDP payload,
918 /// - a [`Output::Callback(Duration)`][1]: the duration of a timer. `process_output` should be
919 /// called at least after the time expires,
920 /// - [`Output::None`][1]: this is returned when `Http3Client` is done and can be destroyed.
921 ///
922 /// The application should call this function repeatedly until a timer value or None is
923 /// returned. After that, the application should call the function again if a new UDP packet is
924 /// received and processed or the timer value expires.
925 ///
926 /// The HTTP/3 neqo implementation drives the HTTP/3 and QUIC layers, therefore this function
927 /// will call both layers:
928 /// - First it calls HTTP/3 layer processing (`process_http3`) to make sure the layer writes
929 /// data to QUIC layer or cancels streams if needed.
930 /// - Then QUIC layer processing is called - [`Connection::process_output`][3]. This produces a
931 /// packet or a timer value. It may also produce new [`ConnectionEvent`][2]s, e.g. connection
932 /// state-change event.
933 /// - Therefore the HTTP/3 layer processing (`process_http3`) is called again.
934 ///
935 /// [1]: ../neqo_transport/enum.Output.html
936 /// [2]: ../neqo_transport/struct.ConnectionEvents.html
937 /// [3]: ../neqo_transport/struct.Connection.html#method.process_output
938 pub fn process_output(&mut self, now: Instant) -> Output {
939 qtrace!("[{self}] Process output");
940
941 // Maybe send() stuff on http3-managed streams
942 self.process_http3(now);
943
944 let out = self.conn.process_output(now);
945
946 // Update H3 for any transport state changes and events
947 self.process_http3(now);
948
949 out
950 }
951
952 /// This function takes the provided result and check for an error.
953 /// An error results in closing the connection.
954 fn check_result<ERR>(&mut self, now: Instant, res: &Res<ERR>) -> bool {
955 match &res {
956 Err(Error::HttpGoaway) => {
957 qinfo!("[{self}] Connection error: goaway stream_id increased");
958 self.close(
959 now,
960 Error::HttpGeneralProtocol.code(),
961 "Connection error: goaway stream_id increased",
962 );
963 true
964 }
965 Err(e) => {
966 qinfo!("[{self}] Connection error: {e}");
967 self.close(now, e.code(), format!("{e}"));
968 true
969 }
970 _ => false,
971 }
972 }
973
974 /// This function checks [`ConnectionEvent`][2]s emitted by the QUIC layer, e.g. connection
975 /// change state events, new incoming stream data is available, a stream is was reset, etc.
976 /// The HTTP/3 layer needs to handle these events. Most of the events are handled by
977 /// [`Http3Connection`][1] by calling appropriate functions, e.g. `handle_state_change`,
978 /// `handle_stream_reset`, etc. [`Http3Connection`][1] handle functionalities that are common
979 /// for the client and server side. Some of the functionalities are specific to the client and
980 /// they are handled by `Http3Client`. For example, [`ConnectionEvent::RecvStreamReadable`][3]
981 /// event is handled by `Http3Client::handle_stream_readable`. The function calls
982 /// `Http3Connection::handle_stream_readable` and then hands the return value as appropriate
983 /// for the client-side.
984 ///
985 /// [1]: https://github.com/mozilla/neqo/blob/main/neqo-http3/src/connection.rs
986 /// [2]: ../neqo_transport/enum.ConnectionEvent.html
987 /// [3]: ../neqo_transport/enum.ConnectionEvent.html#variant.RecvStreamReadable
988 fn check_connection_events(&mut self) -> Res<()> {
989 qtrace!("[{self}] Check connection events");
990 while let Some(e) = self.conn.next_event() {
991 qdebug!("[{self}] check_connection_events - event {e:?}");
992 match e {
993 ConnectionEvent::NewStream { stream_id } => {
994 // During this event we only add a new stream to the Http3Connection stream
995 // list, with NewStreamHeadReader stream handler.
996 // This function will not read from the stream and try to decode the stream.
997 // RecvStreamReadable will be emitted after this event and reading, i.e.
998 // decoding of a stream will happen during that event.
999 self.base_handler.add_new_stream(stream_id);
1000 }
1001 ConnectionEvent::SendStreamWritable { stream_id } => {
1002 if let Some(s) = self.base_handler.send_streams_mut().get_mut(&stream_id) {
1003 s.stream_writable();
1004 }
1005 }
1006 ConnectionEvent::RecvStreamReadable { stream_id } => {
1007 self.handle_stream_readable(stream_id)?;
1008 }
1009 ConnectionEvent::RecvStreamReset {
1010 stream_id,
1011 app_error,
1012 } => self
1013 .base_handler
1014 .handle_stream_reset(stream_id, app_error, &mut self.conn)?,
1015 ConnectionEvent::SendStreamStopSending {
1016 stream_id,
1017 app_error,
1018 } => self.base_handler.handle_stream_stop_sending(
1019 stream_id,
1020 app_error,
1021 &mut self.conn,
1022 )?,
1023
1024 ConnectionEvent::SendStreamCreatable { stream_type } => {
1025 self.events.new_requests_creatable(stream_type);
1026 }
1027 ConnectionEvent::AuthenticationNeeded => self.events.authentication_needed(),
1028 ConnectionEvent::EchFallbackAuthenticationNeeded { public_name } => {
1029 self.events.ech_fallback_authentication_needed(public_name);
1030 }
1031 ConnectionEvent::StateChange(state) => {
1032 if self
1033 .base_handler
1034 .handle_state_change(&mut self.conn, &state)?
1035 {
1036 self.events
1037 .connection_state_change(self.base_handler.state().clone());
1038 }
1039 }
1040 ConnectionEvent::ZeroRttRejected => {
1041 self.base_handler.handle_zero_rtt_rejected()?;
1042 self.events.zero_rtt_rejected();
1043 self.push_handler.borrow_mut().handle_zero_rtt_rejected();
1044 }
1045 ConnectionEvent::ResumptionToken(token) => {
1046 if let Some(t) = self.encode_resumption_token(&token) {
1047 self.events.resumption_token(t);
1048 }
1049 }
1050 ConnectionEvent::Datagram(dgram) => {
1051 self.base_handler.handle_datagram(&dgram);
1052 }
1053 ConnectionEvent::SendStreamComplete { .. }
1054 | ConnectionEvent::OutgoingDatagramOutcome { .. }
1055 | ConnectionEvent::IncomingDatagramDropped => {}
1056 }
1057 }
1058 Ok(())
1059 }
1060
1061 /// This function handled new data available on a stream. It calls
1062 /// `Http3Client::handle_stream_readable` and handles its response. Reading streams are mostly
1063 /// handled by [`Http3Connection`][1] because most part of it is common for the client and
1064 /// server. The following actions need to be handled by the client-specific code:
1065 /// - `ReceiveOutput::NewStream(NewStreamType::Push(_))` - the server cannot receive a push
1066 /// stream,
1067 /// - `ReceiveOutput::NewStream(NewStreamType::Http)` - client cannot receive a
1068 /// server-initiated HTTP request,
1069 /// - `ReceiveOutput::NewStream(NewStreamType::WebTransportStream(_))` - because
1070 /// `Http3ClientEvents`is needed and events handler is specific to the client.
1071 /// - `ReceiveOutput::ControlFrames(control_frames)` - some control frame handling differs
1072 /// between the client and the server:
1073 /// - `HFrame::CancelPush` - only the client-side may receive it,
1074 /// - `HFrame::MaxPushId { .. }`, `HFrame::PriorityUpdateRequest { .. } ` and
1075 /// `HFrame::PriorityUpdatePush` can only be receive on the server side,
1076 /// - `HFrame::Goaway { stream_id }` needs specific handling by the client by the protocol
1077 /// specification.
1078 ///
1079 /// [1]: https://github.com/mozilla/neqo/blob/main/neqo-http3/src/connection.rs
1080 fn handle_stream_readable(&mut self, stream_id: StreamId) -> Res<()> {
1081 match self
1082 .base_handler
1083 .handle_stream_readable(&mut self.conn, stream_id)?
1084 {
1085 ReceiveOutput::NewStream(NewStreamType::Push(push_id)) => {
1086 self.handle_new_push_stream(stream_id, push_id)
1087 }
1088 ReceiveOutput::NewStream(NewStreamType::Http(_)) => Err(Error::HttpStreamCreation),
1089 ReceiveOutput::NewStream(NewStreamType::WebTransportStream(session_id)) => {
1090 self.base_handler.webtransport_create_stream_remote(
1091 StreamId::from(session_id),
1092 stream_id,
1093 Box::new(self.events.clone()),
1094 Box::new(self.events.clone()),
1095 )?;
1096 let res = self
1097 .base_handler
1098 .handle_stream_readable(&mut self.conn, stream_id)?;
1099 debug_assert!(matches!(res, ReceiveOutput::NoOutput));
1100 Ok(())
1101 }
1102 ReceiveOutput::ControlFrames(control_frames) => {
1103 for f in control_frames {
1104 match f {
1105 HFrame::CancelPush { push_id } => self
1106 .push_handler
1107 .borrow_mut()
1108 .handle_cancel_push(push_id, &mut self.conn, &mut self.base_handler),
1109 HFrame::MaxPushId { .. }
1110 | HFrame::PriorityUpdateRequest { .. }
1111 | HFrame::PriorityUpdatePush { .. } => Err(Error::HttpFrameUnexpected),
1112 HFrame::Goaway { stream_id } => self.handle_goaway(stream_id),
1113 _ => {
1114 unreachable!(
1115 "we should only put MaxPushId, Goaway and PriorityUpdates into control_frames"
1116 );
1117 }
1118 }?;
1119 }
1120 Ok(())
1121 }
1122 _ => Ok(()),
1123 }
1124 }
1125
1126 fn handle_new_push_stream(&mut self, stream_id: StreamId, push_id: PushId) -> Res<()> {
1127 if !self.push_handler.borrow().can_receive_push() {
1128 return Err(Error::HttpId);
1129 }
1130
1131 // Add a new push stream to `PushController`. `add_new_push_stream` may return an error
1132 // (this will be a connection error) or a bool.
1133 // If false is returned that means that the stream should be reset because the push has
1134 // been already canceled (CANCEL_PUSH frame or canceling push from the application).
1135 if !self
1136 .push_handler
1137 .borrow_mut()
1138 .add_new_push_stream(push_id, stream_id)?
1139 {
1140 // We are not interested in the result of stream_stop_sending, we are not interested
1141 // in this stream.
1142 drop(
1143 self.conn
1144 .stream_stop_sending(stream_id, Error::HttpRequestCancelled.code()),
1145 );
1146 return Ok(());
1147 }
1148
1149 self.base_handler.add_recv_stream(
1150 stream_id,
1151 Box::new(RecvMessage::new(
1152 &RecvMessageInfo {
1153 message_type: MessageType::Response,
1154 stream_type: Http3StreamType::Push,
1155 stream_id,
1156 first_frame_type: None,
1157 },
1158 Rc::clone(self.base_handler.qpack_decoder()),
1159 Box::new(RecvPushEvents::new(push_id, Rc::clone(&self.push_handler))),
1160 None,
1161 // TODO: think about the right priority for the push streams.
1162 PriorityHandler::new(true, Priority::default()),
1163 )),
1164 );
1165 let res = self
1166 .base_handler
1167 .handle_stream_readable(&mut self.conn, stream_id)?;
1168 debug_assert!(matches!(res, ReceiveOutput::NoOutput));
1169 Ok(())
1170 }
1171
1172 fn handle_goaway(&mut self, goaway_stream_id: StreamId) -> Res<()> {
1173 qinfo!("[{self}] handle_goaway {goaway_stream_id}");
1174
1175 if goaway_stream_id.is_uni() || goaway_stream_id.is_server_initiated() {
1176 return Err(Error::HttpId);
1177 }
1178
1179 match self.base_handler.state_mut() {
1180 Http3State::Connected => {
1181 self.base_handler
1182 .set_state(Http3State::GoingAway(goaway_stream_id));
1183 }
1184 Http3State::GoingAway(ref mut stream_id) => {
1185 if goaway_stream_id > *stream_id {
1186 return Err(Error::HttpGoaway);
1187 }
1188 *stream_id = goaway_stream_id;
1189 }
1190 Http3State::Closing(..) | Http3State::Closed(..) => {}
1191 _ => unreachable!("Should not receive Goaway frame in this state"),
1192 }
1193
1194 // Issue reset events for streams >= goaway stream id
1195 let send_ids: Vec<StreamId> = self
1196 .base_handler
1197 .send_streams()
1198 .iter()
1199 .filter_map(id_gte(goaway_stream_id))
1200 .collect();
1201 for id in send_ids {
1202 // We do not care about streams that are going to be closed.
1203 drop(self.base_handler.handle_stream_stop_sending(
1204 id,
1205 Error::HttpRequestRejected.code(),
1206 &mut self.conn,
1207 ));
1208 }
1209
1210 let recv_ids: Vec<StreamId> = self
1211 .base_handler
1212 .recv_streams()
1213 .iter()
1214 .filter_map(id_gte(goaway_stream_id))
1215 .collect();
1216 for id in recv_ids {
1217 // We do not care about streams that are going to be closed.
1218 drop(self.base_handler.handle_stream_reset(
1219 id,
1220 Error::HttpRequestRejected.code(),
1221 &mut self.conn,
1222 ));
1223 }
1224
1225 self.events.goaway_received();
1226
1227 Ok(())
1228 }
1229
1230 /// Increases `max_stream_data` for a `stream_id`.
1231 ///
1232 /// # Errors
1233 ///
1234 /// Returns `InvalidStreamId` if a stream does not exist or the receiving
1235 /// side is closed.
1236 pub fn set_stream_max_data(&mut self, stream_id: StreamId, max_data: u64) -> Res<()> {
1237 self.conn.set_stream_max_data(stream_id, max_data)?;
1238 Ok(())
1239 }
1240
1241 #[must_use]
1242 pub fn qpack_decoder_stats(&self) -> QpackStats {
1243 self.base_handler.qpack_decoder().borrow().stats()
1244 }
1245
1246 #[must_use]
1247 pub fn qpack_encoder_stats(&self) -> QpackStats {
1248 self.base_handler.qpack_encoder().borrow().stats()
1249 }
1250
1251 #[must_use]
1252 pub fn transport_stats(&self) -> TransportStats {
1253 self.conn.stats()
1254 }
1255
1256 #[must_use]
1257 pub const fn webtransport_enabled(&self) -> bool {
1258 self.base_handler.webtransport_enabled()
1259 }
1260 }
1261
1262 impl EventProvider for Http3Client {
1263 type Event = Http3ClientEvent;
1264
1265 /// Return true if there are outstanding events.
1266 fn has_events(&self) -> bool {
1267 self.events.has_events()
1268 }
1269
1270 /// Get events that indicate state changes on the connection. This method
1271 /// correctly handles cases where handling one event can obsolete
1272 /// previously-queued events, or cause new events to be generated.
1273 fn next_event(&mut self) -> Option<Self::Event> {
1274 self.events.next_event()
1275 }
1276 }
1277
1278 #[cfg(test)]
1279 mod tests {
1280 use std::time::Duration;
1281
1282 use neqo_common::{event::Provider as _, qtrace, Datagram, Decoder, Encoder};
1283 use neqo_crypto::{AllowZeroRtt, AntiReplay, ResumptionToken};
1284 use neqo_qpack::{encoder::QPackEncoder, QpackSettings};
1285 use neqo_transport::{
1286 CloseReason, ConnectionEvent, ConnectionParameters, Output, State, StreamId, StreamType,
1287 Version, INITIAL_RECV_WINDOW_SIZE, MIN_INITIAL_PACKET_SIZE,
1288 };
1289 use test_fixture::{
1290 anti_replay, default_server_h3, fixture_init, new_server, now,
1291 CountingConnectionIdGenerator, DEFAULT_ADDR, DEFAULT_ALPN_H3, DEFAULT_KEYS,
1292 DEFAULT_SERVER_NAME,
1293 };
1294
1295 use super::{
1296 AuthenticationStatus, Connection, Error, HSettings, Header, Http3Client, Http3ClientEvent,
1297 Http3Parameters, Http3State, Rc, RefCell,
1298 };
1299 use crate::{
1300 frames::{HFrame, H3_FRAME_TYPE_SETTINGS, H3_RESERVED_FRAME_TYPES},
1301 qpack_encoder_receiver::EncoderRecvStream,
1302 settings::{HSetting, HSettingType, H3_RESERVED_SETTINGS},
1303 Http3Server, Priority, PushId, RecvStream as _,
1304 };
1305
1306 fn assert_closed(client: &Http3Client, expected: &Error) {
1307 match client.state() {
1308 Http3State::Closing(err) | Http3State::Closed(err) => {
1309 assert_eq!(err, CloseReason::Application(expected.code()));
1310 }
1311 _ => panic!("Wrong state {:?}", client.state()),
1312 }
1313 }
1314
1315 /// Create a http3 client with default configuration.
1316 pub fn default_http3_client() -> Http3Client {
1317 default_http3_client_param(100)
1318 }
1319
1320 pub fn default_http3_client_param(max_table_size: u64) -> Http3Client {
1321 fixture_init();
1322 Http3Client::new(
1323 DEFAULT_SERVER_NAME,
1324 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
1325 DEFAULT_ADDR,
1326 DEFAULT_ADDR,
1327 Http3Parameters::default()
1328 .connection_parameters(
1329 // Disable compatible upgrade, which complicates tests.
1330 ConnectionParameters::default()
1331 .versions(Version::default(), vec![Version::default()]),
1332 )
1333 .max_table_size_encoder(max_table_size)
1334 .max_table_size_decoder(max_table_size)
1335 .max_blocked_streams(100)
1336 .max_concurrent_push_streams(5),
1337 now(),
1338 )
1339 .expect("create a default client")
1340 }
1341
1342 const CONTROL_STREAM_TYPE: &[u8] = &[0x0];
1343
1344 // Encoder stream data
1345 const ENCODER_STREAM_DATA: &[u8] = &[0x2];
1346 const ENCODER_STREAM_CAP_INSTRUCTION: &[u8] = &[0x3f, 0x45];
1347
1348 // Encoder stream data with a change capacity instruction(0x3f, 0x45 = change capacity to 100)
1349 // This data will be send when 0-RTT is used and we already have a max_table_capacity from
1350 // resumed settings.
1351 const ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION: &[u8] = &[0x2, 0x3f, 0x45];
1352
1353 const ENCODER_STREAM_DATA_WITH_CAP_INST_AND_ENCODING_INST: &[u8] = &[
1354 0x2, 0x3f, 0x45, 0x67, 0xa7, 0xd4, 0xe5, 0x1c, 0x85, 0xb1, 0x1f, 0x86, 0xa7, 0xd7, 0x71,
1355 0xd1, 0x69, 0x7f,
1356 ];
1357
1358 // Decoder stream data
1359 const DECODER_STREAM_DATA: &[u8] = &[0x3];
1360
1361 const PUSH_STREAM_TYPE: &[u8] = &[0x1];
1362
1363 const CLIENT_SIDE_CONTROL_STREAM_ID: StreamId = StreamId::new(2);
1364 const CLIENT_SIDE_ENCODER_STREAM_ID: StreamId = StreamId::new(6);
1365 const CLIENT_SIDE_DECODER_STREAM_ID: StreamId = StreamId::new(10);
1366
1367 struct TestServer {
1368 settings: HFrame,
1369 conn: Connection,
1370 control_stream_id: Option<StreamId>,
1371 encoder: Rc<RefCell<QPackEncoder>>,
1372 encoder_receiver: EncoderRecvStream,
1373 encoder_stream_id: Option<StreamId>,
1374 decoder_stream_id: Option<StreamId>,
1375 }
1376
1377 impl TestServer {
1378 pub fn new() -> Self {
1379 Self::new_with_settings(&[
1380 HSetting::new(HSettingType::MaxTableCapacity, 100),
1381 HSetting::new(HSettingType::BlockedStreams, 100),
1382 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
1383 ])
1384 }
1385
1386 pub fn new_with_settings(server_settings: &[HSetting]) -> Self {
1387 fixture_init();
1388 let max_table_size = server_settings
1389 .iter()
1390 .find(|s| s.setting_type == HSettingType::MaxTableCapacity)
1391 .map_or(100, |s| s.value);
1392 let max_blocked_streams = u16::try_from(
1393 server_settings
1394 .iter()
1395 .find(|s| s.setting_type == HSettingType::BlockedStreams)
1396 .map_or(100, |s| s.value),
1397 )
1398 .unwrap();
1399 let qpack = Rc::new(RefCell::new(QPackEncoder::new(
1400 &QpackSettings {
1401 max_table_size_encoder: max_table_size,
1402 max_table_size_decoder: max_table_size,
1403 max_blocked_streams,
1404 },
1405 true,
1406 )));
1407 Self {
1408 settings: HFrame::Settings {
1409 settings: HSettings::new(server_settings),
1410 },
1411 conn: default_server_h3(),
1412 control_stream_id: None,
1413 encoder: Rc::clone(&qpack),
1414 encoder_receiver: EncoderRecvStream::new(CLIENT_SIDE_DECODER_STREAM_ID, qpack),
1415 encoder_stream_id: None,
1416 decoder_stream_id: None,
1417 }
1418 }
1419
1420 pub fn new_with_conn(conn: Connection) -> Self {
1421 let qpack = Rc::new(RefCell::new(QPackEncoder::new(
1422 &QpackSettings {
1423 max_table_size_encoder: 128,
1424 max_table_size_decoder: 128,
1425 max_blocked_streams: 0,
1426 },
1427 true,
1428 )));
1429 Self {
1430 settings: HFrame::Settings {
1431 settings: HSettings::new(&[]),
1432 },
1433 conn,
1434 control_stream_id: None,
1435 encoder: Rc::clone(&qpack),
1436 encoder_receiver: EncoderRecvStream::new(CLIENT_SIDE_DECODER_STREAM_ID, qpack),
1437 encoder_stream_id: None,
1438 decoder_stream_id: None,
1439 }
1440 }
1441
1442 pub fn create_qpack_streams(&mut self) {
1443 // Create a QPACK encoder stream
1444 self.encoder_stream_id = Some(self.conn.stream_create(StreamType::UniDi).unwrap());
1445 self.encoder
1446 .borrow_mut()
1447 .add_send_stream(self.encoder_stream_id.unwrap());
1448 self.encoder
1449 .borrow_mut()
1450 .send_encoder_updates(&mut self.conn)
1451 .unwrap();
1452
1453 // Create decoder stream
1454 self.decoder_stream_id = Some(self.conn.stream_create(StreamType::UniDi).unwrap());
1455 assert_eq!(
1456 self.conn
1457 .stream_send(self.decoder_stream_id.unwrap(), DECODER_STREAM_DATA)
1458 .unwrap(),
1459 1
1460 );
1461 }
1462
1463 pub fn create_control_stream(&mut self) {
1464 // Create control stream
1465 let control = self.conn.stream_create(StreamType::UniDi).unwrap();
1466 qtrace!("[TestServer] control stream: {control}");
1467 self.control_stream_id = Some(control);
1468 // Send stream type on the control stream.
1469 assert_eq!(
1470 self.conn
1471 .stream_send(self.control_stream_id.unwrap(), CONTROL_STREAM_TYPE)
1472 .unwrap(),
1473 1
1474 );
1475
1476 // Encode a settings frame and send it.
1477 let mut enc = Encoder::default();
1478 self.settings.encode(&mut enc);
1479 assert_eq!(
1480 self.conn
1481 .stream_send(self.control_stream_id.unwrap(), enc.as_ref())
1482 .unwrap(),
1483 enc.len()
1484 );
1485 }
1486
1487 pub fn check_client_control_qpack_streams_no_resumption(&mut self) {
1488 self.check_client_control_qpack_streams(
1489 ENCODER_STREAM_DATA,
1490 EXPECTED_REQUEST_HEADER_FRAME,
1491 false,
1492 true,
1493 );
1494 }
1495
1496 pub fn check_control_qpack_request_streams_resumption(
1497 &mut self,
1498 expect_encoder_stream_data: &[u8],
1499 expect_request_header: &[u8],
1500 expect_request: bool,
1501 ) {
1502 self.check_client_control_qpack_streams(
1503 expect_encoder_stream_data,
1504 expect_request_header,
1505 expect_request,
1506 false,
1507 );
1508 }
1509
1510 // Check that server has received correct settings and qpack streams.
1511 pub fn check_client_control_qpack_streams(
1512 &mut self,
1513 expect_encoder_stream_data: &[u8],
1514 expect_request_header: &[u8],
1515 expect_request: bool,
1516 expect_connected: bool,
1517 ) {
1518 let mut connected = false;
1519 let mut control_stream = false;
1520 let mut qpack_decoder_stream = false;
1521 let mut qpack_encoder_stream = false;
1522 let mut request = false;
1523 while let Some(e) = self.conn.next_event() {
1524 match e {
1525 ConnectionEvent::NewStream { stream_id }
1526 | ConnectionEvent::SendStreamWritable { stream_id } => {
1527 if expect_request {
1528 assert!(matches!(stream_id.as_u64(), 2 | 6 | 10 | 0));
1529 } else {
1530 assert!(matches!(stream_id.as_u64(), 2 | 6 | 10));
1531 }
1532 }
1533 ConnectionEvent::RecvStreamReadable { stream_id } => {
1534 if stream_id == CLIENT_SIDE_CONTROL_STREAM_ID {
1535 self.check_control_stream();
1536 control_stream = true;
1537 } else if stream_id == CLIENT_SIDE_ENCODER_STREAM_ID {
1538 // the qpack encoder stream
1539 self.read_and_check_stream_data(
1540 stream_id,
1541 expect_encoder_stream_data,
1542 false,
1543 );
1544 qpack_encoder_stream = true;
1545 } else if stream_id == CLIENT_SIDE_DECODER_STREAM_ID {
1546 // the qpack decoder stream
1547 self.read_and_check_stream_data(stream_id, DECODER_STREAM_DATA, false);
1548 qpack_decoder_stream = true;
1549 } else if stream_id == 0 {
1550 assert!(expect_request);
1551 self.read_and_check_stream_data(stream_id, expect_request_header, true);
1552 request = true;
1553 } else {
1554 panic!("unexpected event");
1555 }
1556 }
1557 ConnectionEvent::StateChange(State::Connected) => connected = true,
1558 ConnectionEvent::StateChange(_)
1559 | ConnectionEvent::SendStreamCreatable { .. } => {}
1560 _ => panic!("unexpected event"),
1561 }
1562 }
1563 assert_eq!(connected, expect_connected);
1564 assert!(control_stream);
1565 assert!(qpack_encoder_stream);
1566 assert!(qpack_decoder_stream);
1567 assert_eq!(request, expect_request);
1568 }
1569
1570 // Check that the control stream contains default values.
1571 // Expect a SETTINGS frame, some grease, and a MAX_PUSH_ID frame.
1572 // The default test configuration uses:
1573 // - max_table_capacity = 100
1574 // - max_blocked_streams = 100
1575 // and a maximum of 5 push streams.
1576 fn check_control_stream(&mut self) {
1577 let mut buf = [0_u8; 100];
1578 let (amount, fin) = self
1579 .conn
1580 .stream_recv(CLIENT_SIDE_CONTROL_STREAM_ID, &mut buf)
1581 .unwrap();
1582 let mut dec = Decoder::from(&buf[..amount]);
1583 assert_eq!(dec.decode_varint().unwrap(), 0); // control stream type
1584 assert_eq!(dec.decode_varint().unwrap(), 4); // SETTINGS
1585 assert_eq!(
1586 dec.decode_vvec().unwrap(),
1587 &[1, 0x40, 0x64, 7, 0x40, 0x64, 0xab, 0x60, 0x37, 0x42, 0x00]
1588 );
1589
1590 assert_eq!((dec.decode_varint().unwrap() - 0x21) % 0x1f, 0); // Grease
1591 assert!(dec.decode_vvec().unwrap().len() < 8);
1592
1593 assert_eq!(dec.decode_varint().unwrap(), 0xd); // MAX_PUSH_ID
1594 assert_eq!(dec.decode_vvec().unwrap(), &[5]);
1595
1596 assert_eq!(dec.remaining(), 0);
1597 assert!(!fin);
1598 }
1599
1600 pub fn read_and_check_stream_data(
1601 &mut self,
1602 stream_id: StreamId,
1603 expected_data: &[u8],
1604 expected_fin: bool,
1605 ) {
1606 let mut buf = [0_u8; 100];
1607 let (amount, fin) = self.conn.stream_recv(stream_id, &mut buf).unwrap();
1608 assert_eq!(fin, expected_fin);
1609 assert_eq!(amount, expected_data.len());
1610 assert_eq!(&buf[..amount], expected_data);
1611 }
1612
1613 pub fn encode_headers(
1614 &mut self,
1615 stream_id: StreamId,
1616 headers: &[Header],
1617 encoder: &mut Encoder,
1618 ) {
1619 let header_block =
1620 self.encoder
1621 .borrow_mut()
1622 .encode_header_block(&mut self.conn, headers, stream_id);
1623 let hframe = HFrame::Headers {
1624 header_block: header_block.as_ref().to_vec(),
1625 };
1626 hframe.encode(encoder);
1627 }
1628 }
1629
1630 fn handshake_only(client: &mut Http3Client, server: &mut TestServer) -> Output {
1631 assert_eq!(client.state(), Http3State::Initializing);
1632 let out = client.process_output(now());
1633 let out2 = client.process_output(now());
1634 assert_eq!(client.state(), Http3State::Initializing);
1635
1636 assert_eq!(*server.conn.state(), State::Init);
1637 server.conn.process_input(out.dgram().unwrap(), now());
1638 let out = server.conn.process(out2.dgram(), now());
1639 assert_eq!(*server.conn.state(), State::Handshaking);
1640
1641 let out = client.process(out.dgram(), now());
1642 let out = server.conn.process(out.dgram(), now());
1643 let out = client.process(out.dgram(), now());
1644 let out = server.conn.process(out.dgram(), now());
1645 assert!(out.as_dgram_ref().is_none());
1646
1647 let authentication_needed = |e| matches!(e, Http3ClientEvent::AuthenticationNeeded);
1648 assert!(client.events().any(authentication_needed));
1649 client.authenticated(AuthenticationStatus::Ok, now());
1650 out
1651 }
1652
1653 // Perform only QUIC transport handshake.
1654 fn connect_only_transport_with(client: &mut Http3Client, server: &mut TestServer) {
1655 let out = handshake_only(client, server);
1656
1657 let out = client.process(out.dgram(), now());
1658 let connected = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::Connected));
1659 assert!(client.events().any(connected));
1660
1661 assert_eq!(client.state(), Http3State::Connected);
1662 server.conn.process_input(out.dgram().unwrap(), now());
1663 assert!(server.conn.state().connected());
1664 }
1665
1666 // Perform only QUIC transport handshake.
1667 fn connect_only_transport() -> (Http3Client, TestServer) {
1668 let mut client = default_http3_client();
1669 let mut server = TestServer::new();
1670 connect_only_transport_with(&mut client, &mut server);
1671 (client, server)
1672 }
1673
1674 fn send_and_receive_client_settings(client: &mut Http3Client, server: &mut TestServer) {
1675 // send and receive client settings
1676 let out = client.process_output(now());
1677 server.conn.process_input(out.dgram().unwrap(), now());
1678 server.check_client_control_qpack_streams_no_resumption();
1679 }
1680
1681 // Perform QUIC transport handshake and exchange Http3 settings.
1682 fn connect_with(client: &mut Http3Client, server: &mut TestServer) {
1683 connect_only_transport_with(client, server);
1684
1685 send_and_receive_client_settings(client, server);
1686
1687 server.create_control_stream();
1688
1689 server.create_qpack_streams();
1690 // Send the server's control and qpack streams data.
1691 let out = server.conn.process(None::<Datagram>, now());
1692 client.process_input(out.dgram().unwrap(), now());
1693
1694 // assert no error occurred.
1695 assert_eq!(client.state(), Http3State::Connected);
1696 }
1697
1698 // Perform QUIC transport handshake and exchange Http3 settings.
1699 fn connect_with_connection_parameters(
1700 server_conn_params: ConnectionParameters,
1701 ) -> (Http3Client, TestServer) {
1702 // connecting with default max_table_size
1703 let mut client = default_http3_client_param(100);
1704 let server = Connection::new_server(
1705 DEFAULT_KEYS,
1706 DEFAULT_ALPN_H3,
1707 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
1708 server_conn_params,
1709 )
1710 .unwrap();
1711 let mut server = TestServer::new_with_conn(server);
1712 connect_with(&mut client, &mut server);
1713 (client, server)
1714 }
1715
1716 // Perform QUIC transport handshake and exchange Http3 settings.
1717 fn connect() -> (Http3Client, TestServer) {
1718 let mut client = default_http3_client();
1719 let mut server = TestServer::new();
1720 connect_with(&mut client, &mut server);
1721 (client, server)
1722 }
1723
1724 // Fetch request fetch("GET", "https", "something.com", "/", headers).
1725 fn make_request(
1726 client: &mut Http3Client,
1727 close_sending_side: bool,
1728 headers: &[Header],
1729 ) -> StreamId {
1730 let request_stream_id = client
1731 .fetch(
1732 now(),
1733 "GET",
1734 "https://something.com/",
1735 headers,
1736 Priority::default(),
1737 )
1738 .unwrap();
1739 if close_sending_side {
1740 client.stream_close_send(request_stream_id).unwrap();
1741 }
1742 request_stream_id
1743 }
1744
1745 // For fetch request fetch("GET", "https", "something.com", "/", &[])
1746 // the following request header frame will be sent:
1747 const EXPECTED_REQUEST_HEADER_FRAME: &[u8] = &[
1748 0x01, 0x10, 0x00, 0x00, 0xd1, 0xd7, 0x50, 0x89, 0x41, 0xe9, 0x2a, 0x67, 0x35, 0x53, 0x2e,
1749 0x43, 0xd3, 0xc1,
1750 ];
1751
1752 // For fetch request fetch("GET", "https", "something.com", "/", &[(String::from("myheaders",
1753 // "myvalue"))]) the following request header frame will be sent:
1754 const EXPECTED_REQUEST_HEADER_FRAME_VERSION2: &[u8] = &[
1755 0x01, 0x11, 0x02, 0x80, 0xd1, 0xd7, 0x50, 0x89, 0x41, 0xe9, 0x2a, 0x67, 0x35, 0x53, 0x2e,
1756 0x43, 0xd3, 0xc1, 0x10,
1757 ];
1758
1759 const HTTP_HEADER_FRAME_0: &[u8] = &[0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x30];
1760
1761 // The response header from HTTP_HEADER_FRAME (0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x30)
1762 // are decoded into:
1763 fn check_response_header_0(header: &[Header]) {
1764 let expected_response_header_0 = &[
1765 Header::new(":status", "200"),
1766 Header::new("content-length", "0"),
1767 ];
1768 assert_eq!(header, expected_response_header_0);
1769 }
1770
1771 const HTTP_RESPONSE_1: &[u8] = &[
1772 // headers
1773 0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x37, // the first data frame
1774 0x0, 0x3, 0x61, 0x62, 0x63, // the second data frame
1775 0x0, 0x4, 0x64, 0x65, 0x66, 0x67,
1776 ];
1777
1778 const HTTP_RESPONSE_HEADER_ONLY_1: &[u8] = &[
1779 // headers
1780 0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x37,
1781 ];
1782 const HTTP_RESPONSE_DATA_FRAME_1_ONLY_1: &[u8] = &[0x0, 0x3, 0x61, 0x62, 0x63];
1783
1784 const HTTP_RESPONSE_DATA_FRAME_2_ONLY_1: &[u8] = &[0x0, 0x4, 0x64, 0x65, 0x66, 0x67];
1785
1786 // The response header from HTTP_RESPONSE_1 (0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x36) are
1787 // decoded into:
1788 fn check_response_header_1(header: &[Header]) {
1789 let expected_response_header_1 = &[
1790 Header::new(":status", "200"),
1791 Header::new("content-length", "7"),
1792 ];
1793 assert_eq!(header, expected_response_header_1);
1794 }
1795
1796 const EXPECTED_RESPONSE_DATA_1: &[u8] = &[0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67];
1797
1798 const HTTP_RESPONSE_2: &[u8] = &[
1799 // headers
1800 0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x33, // the data frame
1801 0x0, 0x3, 0x61, 0x62, 0x63,
1802 ];
1803
1804 const HTTP_RESPONSE_HEADER_ONLY_2: &[u8] = &[
1805 // headers
1806 0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x33,
1807 ];
1808
1809 const HTTP_RESPONSE_DATA_FRAME_ONLY_2: &[u8] = &[
1810 // the data frame
1811 0x0, 0x3, 0x61, 0x62, 0x63,
1812 ];
1813
1814 // The response header from HTTP_RESPONSE_2 (0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x36) are
1815 // decoded into:
1816 fn check_response_header_2(header: &[Header]) {
1817 let expected_response_header_2 = &[
1818 Header::new(":status", "200"),
1819 Header::new("content-length", "3"),
1820 ];
1821 assert_eq!(header, expected_response_header_2);
1822 }
1823
1824 // The data frame payload from HTTP_RESPONSE_2 is:
1825 const EXPECTED_RESPONSE_DATA_2_FRAME_1: &[u8] = &[0x61, 0x62, 0x63];
1826
1827 fn make_request_and_exchange_pkts(
1828 client: &mut Http3Client,
1829 server: &mut TestServer,
1830 close_sending_side: bool,
1831 ) -> StreamId {
1832 let request_stream_id = make_request(client, close_sending_side, &[]);
1833
1834 let out = client.process_output(now());
1835 server.conn.process_input(out.dgram().unwrap(), now());
1836
1837 // find the new request/response stream and send frame v on it.
1838 while let Some(e) = server.conn.next_event() {
1839 match e {
1840 ConnectionEvent::NewStream { stream_id } => {
1841 assert_eq!(stream_id, request_stream_id);
1842 assert_eq!(stream_id.stream_type(), StreamType::BiDi);
1843 }
1844 ConnectionEvent::RecvStreamReadable { stream_id } => {
1845 if stream_id == CLIENT_SIDE_ENCODER_STREAM_ID {
1846 server.read_and_check_stream_data(
1847 stream_id,
1848 ENCODER_STREAM_CAP_INSTRUCTION,
1849 false,
1850 );
1851 } else {
1852 assert_eq!(stream_id, request_stream_id);
1853 server.read_and_check_stream_data(
1854 stream_id,
1855 EXPECTED_REQUEST_HEADER_FRAME,
1856 close_sending_side,
1857 );
1858 }
1859 }
1860 _ => {}
1861 }
1862 }
1863 let dgram = server.conn.process_output(now()).dgram();
1864 if let Some(d) = dgram {
1865 client.process_input(d, now());
1866 }
1867 request_stream_id
1868 }
1869
1870 fn connect_and_send_request(close_sending_side: bool) -> (Http3Client, TestServer, StreamId) {
1871 let (mut client, mut server) = connect();
1872 let request_stream_id =
1873 make_request_and_exchange_pkts(&mut client, &mut server, close_sending_side);
1874 assert_eq!(request_stream_id, 0);
1875
1876 (client, server, request_stream_id)
1877 }
1878
1879 fn server_send_response_and_exchange_packet(
1880 client: &mut Http3Client,
1881 server: &mut TestServer,
1882 stream_id: StreamId,
1883 response: impl AsRef<[u8]>,
1884 close_stream: bool,
1885 ) {
1886 _ = server
1887 .conn
1888 .stream_send(stream_id, response.as_ref())
1889 .unwrap();
1890 if close_stream {
1891 server.conn.stream_close_send(stream_id).unwrap();
1892 }
1893 let out = server.conn.process(None::<Datagram>, now());
1894 let out = client.process(out.dgram(), now());
1895 drop(server.conn.process(out.dgram(), now()));
1896 }
1897
1898 const PUSH_PROMISE_DATA: &[u8] = &[
1899 0x00, 0x00, 0xd1, 0xd7, 0x50, 0x89, 0x41, 0xe9, 0x2a, 0x67, 0x35, 0x53, 0x2e, 0x43, 0xd3,
1900 0xc1,
1901 ];
1902
1903 fn check_pushpromise_header(header: &[Header]) {
1904 let expected_response_header_1 = &[
1905 Header::new(":method", "GET"),
1906 Header::new(":scheme", "https"),
1907 Header::new(":authority", "something.com"),
1908 Header::new(":path", "/"),
1909 ];
1910 assert_eq!(header, expected_response_header_1);
1911 }
1912
1913 // Send a push promise with push_id and request_stream_id.
1914 fn send_push_promise(conn: &mut Connection, stream_id: StreamId, push_id: PushId) {
1915 let frame = HFrame::PushPromise {
1916 push_id,
1917 header_block: PUSH_PROMISE_DATA.to_vec(),
1918 };
1919 let mut d = Encoder::default();
1920 frame.encode(&mut d);
1921 _ = conn.stream_send(stream_id, d.as_ref()).unwrap();
1922 }
1923
1924 fn send_push_data_and_exchange_packets(
1925 client: &mut Http3Client,
1926 server: &mut TestServer,
1927 push_id: PushId,
1928 close_push_stream: bool,
1929 ) -> StreamId {
1930 let push_stream_id = send_push_data(&mut server.conn, push_id, close_push_stream);
1931
1932 let out = server.conn.process_output(now());
1933 let out = client.process(out.dgram(), now());
1934 drop(server.conn.process(out.dgram(), now()));
1935
1936 push_stream_id
1937 }
1938
1939 fn send_push_promise_and_exchange_packets(
1940 client: &mut Http3Client,
1941 server: &mut TestServer,
1942 stream_id: StreamId,
1943 push_id: PushId,
1944 ) {
1945 send_push_promise(&mut server.conn, stream_id, push_id);
1946
1947 let out = server.conn.process_output(now());
1948 let out = client.process(out.dgram(), now());
1949 drop(server.conn.process(out.dgram(), now()));
1950 }
1951
1952 fn send_cancel_push_and_exchange_packets(
1953 client: &mut Http3Client,
1954 server: &mut TestServer,
1955 push_id: PushId,
1956 ) {
1957 let frame = HFrame::CancelPush { push_id };
1958 let mut d = Encoder::default();
1959 frame.encode(&mut d);
1960 server
1961 .conn
1962 .stream_send(server.control_stream_id.unwrap(), d.as_ref())
1963 .unwrap();
1964
1965 let out = server.conn.process_output(now());
1966 let out = client.process(out.dgram(), now());
1967 drop(server.conn.process(out.dgram(), now()));
1968 }
1969
1970 const PUSH_DATA: &[u8] = &[
1971 // headers
1972 0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x34, // the data frame.
1973 0x0, 0x4, 0x61, 0x62, 0x63, 0x64,
1974 ];
1975
1976 // The response header from PUSH_DATA (0x01, 0x06, 0x00, 0x00, 0xd9, 0x54, 0x01, 0x34) are
1977 // decoded into:
1978 fn check_push_response_header(header: &[Header]) {
1979 let expected_push_response_header = [
1980 Header::new(":status", "200"),
1981 Header::new("content-length", "4"),
1982 ];
1983 assert_eq!(header, &expected_push_response_header[..]);
1984 }
1985
1986 // The data frame payload from PUSH_DATA is:
1987 const EXPECTED_PUSH_RESPONSE_DATA_FRAME: &[u8] = &[0x61, 0x62, 0x63, 0x64];
1988
1989 // Send push data on a push stream:
1990 // 1) push_stream_type PUSH_STREAM_TYPE
1991 // 2) push_id
1992 // 3) PUSH_DATA that contains encoded headers and a data frame.
1993 // This function can only handle small push_id numbers that fit in a varint of length 1 byte.
1994 fn send_data_on_push(
1995 conn: &mut Connection,
1996 push_stream_id: StreamId,
1997 push_id: PushId,
1998 data: impl AsRef<[u8]>,
1999 close_push_stream: bool,
2000 ) {
2001 // send data
2002 _ = conn.stream_send(push_stream_id, PUSH_STREAM_TYPE).unwrap();
2003 _ = conn
2004 .stream_send(push_stream_id, &[u8::try_from(u64::from(push_id)).unwrap()])
2005 .unwrap();
2006 _ = conn.stream_send(push_stream_id, data.as_ref()).unwrap();
2007 if close_push_stream {
2008 conn.stream_close_send(push_stream_id).unwrap();
2009 }
2010 }
2011
2012 // Send push data on a push stream:
2013 // 1) push_stream_type PUSH_STREAM_TYPE
2014 // 2) push_id
2015 // 3) PUSH_DATA that contains encoded headers and a data frame.
2016 // This function can only handle small push_id numbers that fit in a varint of length 1 byte.
2017 fn send_push_data(conn: &mut Connection, push_id: PushId, close_push_stream: bool) -> StreamId {
2018 send_push_with_data(conn, push_id, PUSH_DATA, close_push_stream)
2019 }
2020
2021 // Send push data on a push stream:
2022 // 1) push_stream_type PUSH_STREAM_TYPE
2023 // 2) push_id
2024 // 3) and supplied push data.
2025 // This function can only handle small push_id numbers that fit in a varint of length 1 byte.
2026 fn send_push_with_data(
2027 conn: &mut Connection,
2028 push_id: PushId,
2029 data: &[u8],
2030 close_push_stream: bool,
2031 ) -> StreamId {
2032 // create a push stream
2033 let push_stream_id = conn.stream_create(StreamType::UniDi).unwrap();
2034 // send data
2035 send_data_on_push(conn, push_stream_id, push_id, data, close_push_stream);
2036 push_stream_id
2037 }
2038
2039 struct PushPromiseInfo {
2040 pub push_id: PushId,
2041 pub ref_stream_id: StreamId,
2042 }
2043
2044 // Helper function: read response when a server sends:
2045 // - HTTP_RESPONSE_2 on the request_stream_id stream,
2046 // - a number of push promises described by a list of PushPromiseInfo.
2047 // - and a push streams with push_id in the push_streams list.
2048 // All push stream contain PUSH_DATA that decodes to headers (that can be checked by calling
2049 // check_push_response_header) and EXPECTED_PUSH_RESPONSE_DATA_FRAME
2050 fn read_response_and_push_events(
2051 client: &mut Http3Client,
2052 push_promises: &[PushPromiseInfo],
2053 push_streams: &[PushId],
2054 response_stream_id: StreamId,
2055 ) {
2056 let mut num_push_promises = 0;
2057 let mut num_push_stream_headers = 0;
2058 let mut num_push_stream_data = 0;
2059 while let Some(e) = client.next_event() {
2060 match e {
2061 Http3ClientEvent::PushPromise {
2062 push_id,
2063 request_stream_id,
2064 headers,
2065 } => {
2066 assert!(push_promises
2067 .iter()
2068 .any(|p| p.push_id == push_id && p.ref_stream_id == request_stream_id));
2069 check_pushpromise_header(&headers[..]);
2070 num_push_promises += 1;
2071 }
2072 Http3ClientEvent::PushHeaderReady {
2073 push_id,
2074 headers,
2075 interim,
2076 fin,
2077 } => {
2078 assert!(push_streams.contains(&push_id));
2079 check_push_response_header(&headers);
2080 num_push_stream_headers += 1;
2081 assert!(!fin);
2082 assert!(!interim);
2083 }
2084 Http3ClientEvent::PushDataReadable { push_id } => {
2085 assert!(push_streams.contains(&push_id));
2086 let mut buf = [0_u8; 100];
2087 let (amount, fin) = client.push_read_data(now(), push_id, &mut buf).unwrap();
2088 assert!(fin);
2089 assert_eq!(amount, EXPECTED_PUSH_RESPONSE_DATA_FRAME.len());
2090 assert_eq!(&buf[..amount], EXPECTED_PUSH_RESPONSE_DATA_FRAME);
2091 num_push_stream_data += 1;
2092 }
2093 Http3ClientEvent::HeaderReady {
2094 stream_id,
2095 headers,
2096 interim,
2097 fin,
2098 } => {
2099 assert_eq!(stream_id, response_stream_id);
2100 check_response_header_2(&headers);
2101 assert!(!fin);
2102 assert!(!interim);
2103 }
2104 Http3ClientEvent::DataReadable { stream_id } => {
2105 assert_eq!(stream_id, response_stream_id);
2106 let mut buf = [0_u8; 100];
2107 let (amount, _) = client.read_data(now(), stream_id, &mut buf).unwrap();
2108 assert_eq!(amount, EXPECTED_RESPONSE_DATA_2_FRAME_1.len());
2109 assert_eq!(&buf[..amount], EXPECTED_RESPONSE_DATA_2_FRAME_1);
2110 }
2111 _ => {}
2112 }
2113 }
2114
2115 assert_eq!(num_push_promises, push_promises.len());
2116 assert_eq!(num_push_stream_headers, push_streams.len());
2117 assert_eq!(num_push_stream_data, push_streams.len());
2118 }
2119
2120 // Client: Test receiving a new control stream and a SETTINGS frame.
2121 #[test]
2122 fn client_connect_and_exchange_qpack_and_control_streams() {
2123 drop(connect());
2124 }
2125
2126 // Client: Test that the connection will be closed if control stream
2127 // has been closed.
2128 #[test]
2129 fn client_close_control_stream() {
2130 let (mut client, mut server) = connect();
2131 server
2132 .conn
2133 .stream_close_send(server.control_stream_id.unwrap())
2134 .unwrap();
2135 let out = server.conn.process_output(now());
2136 client.process(out.dgram(), now());
2137 assert_closed(&client, &Error::HttpClosedCriticalStream);
2138 }
2139
2140 // Client: Test that the connection will be closed if the local control stream
2141 // has been reset.
2142 #[test]
2143 fn client_reset_control_stream() {
2144 let (mut client, mut server) = connect();
2145 server
2146 .conn
2147 .stream_reset_send(server.control_stream_id.unwrap(), Error::HttpNoError.code())
2148 .unwrap();
2149 let out = server.conn.process_output(now());
2150 client.process(out.dgram(), now());
2151 assert_closed(&client, &Error::HttpClosedCriticalStream);
2152 }
2153
2154 // Client: Test that the connection will be closed if the server side encoder stream
2155 // has been reset.
2156 #[test]
2157 fn client_reset_server_side_encoder_stream() {
2158 let (mut client, mut server) = connect();
2159 server
2160 .conn
2161 .stream_reset_send(server.encoder_stream_id.unwrap(), Error::HttpNoError.code())
2162 .unwrap();
2163 let out = server.conn.process_output(now());
2164 client.process(out.dgram(), now());
2165 assert_closed(&client, &Error::HttpClosedCriticalStream);
2166 }
2167
2168 // Client: Test that the connection will be closed if the server side decoder stream
2169 // has been reset.
2170 #[test]
2171 fn client_reset_server_side_decoder_stream() {
2172 let (mut client, mut server) = connect();
2173 server
2174 .conn
2175 .stream_reset_send(server.decoder_stream_id.unwrap(), Error::HttpNoError.code())
2176 .unwrap();
2177 let out = server.conn.process_output(now());
2178 client.process(out.dgram(), now());
2179 assert_closed(&client, &Error::HttpClosedCriticalStream);
2180 }
2181
2182 // Client: Test that the connection will be closed if the local control stream
2183 // has received a stop_sending.
2184 #[test]
2185 fn client_stop_sending_control_stream() {
2186 let (mut client, mut server) = connect();
2187 server
2188 .conn
2189 .stream_stop_sending(CLIENT_SIDE_CONTROL_STREAM_ID, Error::HttpNoError.code())
2190 .unwrap();
2191 let out = server.conn.process_output(now());
2192 client.process(out.dgram(), now());
2193 assert_closed(&client, &Error::HttpClosedCriticalStream);
2194 }
2195
2196 // Client: Test that the connection will be closed if the client side encoder stream
2197 // has received a stop_sending.
2198 #[test]
2199 fn client_stop_sending_encoder_stream() {
2200 let (mut client, mut server) = connect();
2201 server
2202 .conn
2203 .stream_stop_sending(CLIENT_SIDE_ENCODER_STREAM_ID, Error::HttpNoError.code())
2204 .unwrap();
2205 let out = server.conn.process_output(now());
2206 client.process(out.dgram(), now());
2207 assert_closed(&client, &Error::HttpClosedCriticalStream);
2208 }
2209
2210 // Client: Test that the connection will be closed if the client side decoder stream
2211 // has received a stop_sending.
2212 #[test]
2213 fn client_stop_sending_decoder_stream() {
2214 let (mut client, mut server) = connect();
2215 server
2216 .conn
2217 .stream_stop_sending(CLIENT_SIDE_DECODER_STREAM_ID, Error::HttpNoError.code())
2218 .unwrap();
2219 let out = server.conn.process_output(now());
2220 client.process(out.dgram(), now());
2221 assert_closed(&client, &Error::HttpClosedCriticalStream);
2222 }
2223
2224 // Client: test missing SETTINGS frame
2225 // (the first frame sent is a garbage frame).
2226 #[test]
2227 fn client_missing_settings() {
2228 let (mut client, mut server) = connect_only_transport();
2229 // Create server control stream.
2230 let control_stream = server.conn.stream_create(StreamType::UniDi).unwrap();
2231 // Send a HEADERS frame instead (which contains garbage).
2232 let sent = server
2233 .conn
2234 .stream_send(control_stream, &[0x0, 0x1, 0x3, 0x0, 0x1, 0x2]);
2235 assert_eq!(sent, Ok(6));
2236 let out = server.conn.process_output(now());
2237 client.process(out.dgram(), now());
2238 assert_closed(&client, &Error::HttpMissingSettings);
2239 }
2240
2241 // Client: receiving SETTINGS frame twice causes connection close
2242 // with error HTTP_UNEXPECTED_FRAME.
2243 #[test]
2244 fn client_receive_settings_twice() {
2245 let (mut client, mut server) = connect();
2246 // send the second SETTINGS frame.
2247 let sent = server.conn.stream_send(
2248 server.control_stream_id.unwrap(),
2249 &[0x4, 0x6, 0x1, 0x40, 0x64, 0x7, 0x40, 0x64],
2250 );
2251 assert_eq!(sent, Ok(8));
2252 let out = server.conn.process_output(now());
2253 client.process(out.dgram(), now());
2254 assert_closed(&client, &Error::HttpFrameUnexpected);
2255 }
2256
2257 fn test_wrong_frame_on_control_stream(v: &[u8]) {
2258 let (mut client, mut server) = connect();
2259
2260 // send a frame that is not allowed on the control stream.
2261 _ = server
2262 .conn
2263 .stream_send(server.control_stream_id.unwrap(), v)
2264 .unwrap();
2265
2266 let out = server.conn.process_output(now());
2267 client.process(out.dgram(), now());
2268
2269 assert_closed(&client, &Error::HttpFrameUnexpected);
2270 }
2271
2272 // send DATA frame on a control stream
2273 #[test]
2274 fn data_frame_on_control_stream() {
2275 test_wrong_frame_on_control_stream(&[0x0, 0x2, 0x1, 0x2]);
2276 }
2277
2278 // send HEADERS frame on a control stream
2279 #[test]
2280 fn headers_frame_on_control_stream() {
2281 test_wrong_frame_on_control_stream(&[0x1, 0x2, 0x1, 0x2]);
2282 }
2283
2284 // send PUSH_PROMISE frame on a control stream
2285 #[test]
2286 fn push_promise_frame_on_control_stream() {
2287 test_wrong_frame_on_control_stream(&[0x5, 0x2, 0x1, 0x2]);
2288 }
2289
2290 // send PRIORITY_UPDATE frame on a control stream to the client
2291 #[test]
2292 fn priority_update_request_on_control_stream() {
2293 test_wrong_frame_on_control_stream(&[0x80, 0x0f, 0x07, 0x00, 0x01, 0x03]);
2294 }
2295
2296 #[test]
2297 fn priority_update_push_on_control_stream() {
2298 test_wrong_frame_on_control_stream(&[0x80, 0x0f, 0x07, 0x01, 0x01, 0x03]);
2299 }
2300
2301 fn test_wrong_frame_on_push_stream(v: &[u8]) {
2302 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
2303
2304 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
2305 // Create a push stream
2306 let push_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap();
2307
2308 // Send the push stream type byte, push_id and frame v.
2309 _ = server
2310 .conn
2311 .stream_send(push_stream_id, &[0x01, 0x0])
2312 .unwrap();
2313 _ = server.conn.stream_send(push_stream_id, v).unwrap();
2314
2315 let out = server.conn.process_output(now());
2316 let out = client.process(out.dgram(), now());
2317 drop(server.conn.process(out.dgram(), now()));
2318
2319 assert_closed(&client, &Error::HttpFrameUnexpected);
2320 }
2321
2322 #[test]
2323 fn cancel_push_frame_on_push_stream() {
2324 test_wrong_frame_on_push_stream(&[0x3, 0x1, 0x5]);
2325 }
2326
2327 #[test]
2328 fn settings_frame_on_push_stream() {
2329 test_wrong_frame_on_push_stream(&[0x4, 0x4, 0x6, 0x4, 0x8, 0x4]);
2330 }
2331
2332 #[test]
2333 fn push_promise_frame_on_push_stream() {
2334 test_wrong_frame_on_push_stream(&[0x5, 0x2, 0x1, 0x2]);
2335 }
2336
2337 #[test]
2338 fn priority_update_request_on_push_stream() {
2339 test_wrong_frame_on_push_stream(&[0x80, 0x0f, 0x07, 0x00, 0x01, 0x03]);
2340 }
2341
2342 #[test]
2343 fn priority_update_push_on_push_stream() {
2344 test_wrong_frame_on_push_stream(&[0x80, 0x0f, 0x07, 0x01, 0x01, 0x03]);
2345 }
2346
2347 #[test]
2348 fn goaway_frame_on_push_stream() {
2349 test_wrong_frame_on_push_stream(&[0x7, 0x1, 0x5]);
2350 }
2351
2352 #[test]
2353 fn max_push_id_frame_on_push_stream() {
2354 test_wrong_frame_on_push_stream(&[0xd, 0x1, 0x5]);
2355 }
2356
2357 // send DATA frame before a header frame
2358 #[test]
2359 fn data_frame_on_push_stream() {
2360 test_wrong_frame_on_push_stream(&[0x0, 0x2, 0x1, 0x2]);
2361 }
2362
2363 // Client: receive unknown stream type
2364 // This function also tests getting stream id that does not fit into a single byte.
2365 #[test]
2366 fn client_received_unknown_stream() {
2367 let (mut client, mut server) = connect();
2368
2369 // create a stream with unknown type.
2370 let new_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap();
2371 _ = server
2372 .conn
2373 .stream_send(new_stream_id, &[0x41, 0x19, 0x4, 0x4, 0x6, 0x0, 0x8, 0x0])
2374 .unwrap();
2375 let out = server.conn.process_output(now());
2376 let out = client.process(out.dgram(), now());
2377 drop(server.conn.process(out.dgram(), now()));
2378
2379 // check for stop-sending with Error::HttpStreamCreation.
2380 let mut stop_sending_event_found = false;
2381 while let Some(e) = server.conn.next_event() {
2382 if let ConnectionEvent::SendStreamStopSending {
2383 stream_id,
2384 app_error,
2385 } = e
2386 {
2387 stop_sending_event_found = true;
2388 assert_eq!(stream_id, new_stream_id);
2389 assert_eq!(app_error, Error::HttpStreamCreation.code());
2390 }
2391 }
2392 assert!(stop_sending_event_found);
2393 assert_eq!(client.state(), Http3State::Connected);
2394 }
2395
2396 // Test wrong frame on req/rec stream
2397 fn test_wrong_frame_on_request_stream(v: &[u8]) {
2398 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
2399
2400 _ = server.conn.stream_send(request_stream_id, v).unwrap();
2401
2402 // Generate packet with the above bad h3 input
2403 let out = server.conn.process_output(now());
2404 // Process bad input and close the connection.
2405 drop(client.process(out.dgram(), now()));
2406
2407 assert_closed(&client, &Error::HttpFrameUnexpected);
2408 }
2409
2410 #[test]
2411 fn cancel_push_frame_on_request_stream() {
2412 test_wrong_frame_on_request_stream(&[0x3, 0x1, 0x5]);
2413 }
2414
2415 #[test]
2416 fn settings_frame_on_request_stream() {
2417 test_wrong_frame_on_request_stream(&[0x4, 0x4, 0x6, 0x4, 0x8, 0x4]);
2418 }
2419
2420 #[test]
2421 fn goaway_frame_on_request_stream() {
2422 test_wrong_frame_on_request_stream(&[0x7, 0x1, 0x5]);
2423 }
2424
2425 #[test]
2426 fn max_push_id_frame_on_request_stream() {
2427 test_wrong_frame_on_request_stream(&[0xd, 0x1, 0x5]);
2428 }
2429
2430 #[test]
2431 fn priority_update_request_on_request_stream() {
2432 test_wrong_frame_on_request_stream(&[0x80, 0x0f, 0x07, 0x00, 0x01, 0x03]);
2433 }
2434
2435 #[test]
2436 fn priority_update_push_on_request_stream() {
2437 test_wrong_frame_on_request_stream(&[0x80, 0x0f, 0x07, 0x01, 0x01, 0x03]);
2438 }
2439
2440 // Test reading of a slowly streamed frame. bytes are received one by one
2441 #[test]
2442 fn frame_reading() {
2443 let (mut client, mut server) = connect_only_transport();
2444
2445 // create a control stream.
2446 let control_stream = server.conn.stream_create(StreamType::UniDi).unwrap();
2447
2448 // send the stream type
2449 let mut sent = server.conn.stream_send(control_stream, &[0x0]);
2450 assert_eq!(sent, Ok(1));
2451 let out = server.conn.process_output(now());
2452 client.process(out.dgram(), now());
2453
2454 // start sending SETTINGS frame
2455 sent = server.conn.stream_send(control_stream, &[0x4]);
2456 assert_eq!(sent, Ok(1));
2457 let out = server.conn.process_output(now());
2458 client.process(out.dgram(), now());
2459
2460 sent = server.conn.stream_send(control_stream, &[0x4]);
2461 assert_eq!(sent, Ok(1));
2462 let out = server.conn.process_output(now());
2463 client.process(out.dgram(), now());
2464
2465 sent = server.conn.stream_send(control_stream, &[0x6]);
2466 assert_eq!(sent, Ok(1));
2467 let out = server.conn.process_output(now());
2468 client.process(out.dgram(), now());
2469
2470 sent = server.conn.stream_send(control_stream, &[0x0]);
2471 assert_eq!(sent, Ok(1));
2472 let out = server.conn.process_output(now());
2473 client.process(out.dgram(), now());
2474
2475 sent = server.conn.stream_send(control_stream, &[0x8]);
2476 assert_eq!(sent, Ok(1));
2477 let out = server.conn.process_output(now());
2478 client.process(out.dgram(), now());
2479
2480 sent = server.conn.stream_send(control_stream, &[0x0]);
2481 assert_eq!(sent, Ok(1));
2482 let out = server.conn.process_output(now());
2483 client.process(out.dgram(), now());
2484
2485 assert_eq!(client.state(), Http3State::Connected);
2486
2487 // Now test PushPromise
2488 sent = server.conn.stream_send(control_stream, &[0x5]);
2489 assert_eq!(sent, Ok(1));
2490 let out = server.conn.process_output(now());
2491 client.process(out.dgram(), now());
2492
2493 sent = server.conn.stream_send(control_stream, &[0x5]);
2494 assert_eq!(sent, Ok(1));
2495 let out = server.conn.process_output(now());
2496 client.process(out.dgram(), now());
2497
2498 sent = server.conn.stream_send(control_stream, &[0x4]);
2499 assert_eq!(sent, Ok(1));
2500 let out = server.conn.process_output(now());
2501 client.process(out.dgram(), now());
2502
2503 sent = server.conn.stream_send(control_stream, &[0x61]);
2504 assert_eq!(sent, Ok(1));
2505 let out = server.conn.process_output(now());
2506 client.process(out.dgram(), now());
2507
2508 sent = server.conn.stream_send(control_stream, &[0x62]);
2509 assert_eq!(sent, Ok(1));
2510 let out = server.conn.process_output(now());
2511 client.process(out.dgram(), now());
2512
2513 sent = server.conn.stream_send(control_stream, &[0x63]);
2514 assert_eq!(sent, Ok(1));
2515 let out = server.conn.process_output(now());
2516 client.process(out.dgram(), now());
2517
2518 sent = server.conn.stream_send(control_stream, &[0x64]);
2519 assert_eq!(sent, Ok(1));
2520 let out = server.conn.process_output(now());
2521 client.process(out.dgram(), now());
2522
2523 // PUSH_PROMISE on a control stream will cause an error
2524 assert_closed(&client, &Error::HttpFrameUnexpected);
2525 }
2526
2527 #[test]
2528 fn fetch_basic() {
2529 // Connect exchange headers and send a request. Also check if the correct header frame has
2530 // been sent.
2531 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
2532
2533 // send response - 200 Content-Length: 7
2534 // with content: 'abcdefg'.
2535 // The content will be send in 2 DATA frames.
2536 server_send_response_and_exchange_packet(
2537 &mut client,
2538 &mut server,
2539 request_stream_id,
2540 HTTP_RESPONSE_1,
2541 true,
2542 );
2543
2544 let http_events = client.events().collect::<Vec<_>>();
2545 assert_eq!(http_events.len(), 2);
2546 for e in http_events {
2547 match e {
2548 Http3ClientEvent::HeaderReady {
2549 stream_id,
2550 headers,
2551 interim,
2552 fin,
2553 } => {
2554 assert_eq!(stream_id, request_stream_id);
2555 check_response_header_1(&headers);
2556 assert!(!fin);
2557 assert!(!interim);
2558 }
2559 Http3ClientEvent::DataReadable { stream_id } => {
2560 assert_eq!(stream_id, request_stream_id);
2561 let mut buf = [0_u8; 100];
2562 let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
2563 assert!(fin);
2564 assert_eq!(amount, EXPECTED_RESPONSE_DATA_1.len());
2565 assert_eq!(&buf[..amount], EXPECTED_RESPONSE_DATA_1);
2566 }
2567 _ => {}
2568 }
2569 }
2570
2571 // after this stream will be removed from conn. We will check this by trying to read
2572 // from the stream and that should fail.
2573 let mut buf = [0_u8; 100];
2574 let res = client.read_data(now(), request_stream_id, &mut buf);
2575 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
2576
2577 client.close(now(), 0, "");
2578 }
2579
2580 /// Force both endpoints into an idle state.
2581 /// Do this by opening unidirectional streams at both endpoints and sending
2582 /// a partial unidirectional stream type (which the receiver has to buffer),
2583 /// then delivering packets out of order.
2584 /// This forces the receiver to create an acknowledgment, which will allow
2585 /// the peer to become idle.
2586 fn force_idle(client: &mut Http3Client, server: &mut TestServer) {
2587 // Send a partial unidirectional stream ID.
2588 // Note that this can't close the stream as that causes the receiver
2589 // to send `MAX_STREAMS`, which would prevent it from becoming idle.
2590 fn dgram(c: &mut Connection) -> Datagram {
2591 let stream = c.stream_create(StreamType::UniDi).unwrap();
2592 _ = c.stream_send(stream, &[0xc0]).unwrap();
2593 c.process_output(now()).dgram().unwrap()
2594 }
2595
2596 let d1 = dgram(&mut client.conn);
2597 let d2 = dgram(&mut client.conn);
2598 server.conn.process_input(d2, now());
2599 server.conn.process_input(d1, now());
2600 let d3 = dgram(&mut server.conn);
2601 let d4 = dgram(&mut server.conn);
2602 client.process_input(d4, now());
2603 client.process_input(d3, now());
2604 let ack = client.process_output(now()).dgram();
2605 server.conn.process_input(ack.unwrap(), now());
2606 }
2607
2608 /// The client should keep a connection alive if it has unanswered requests.
2609 #[test]
2610 fn fetch_keep_alive() {
2611 let (mut client, mut server, _request_stream_id) = connect_and_send_request(true);
2612 force_idle(&mut client, &mut server);
2613
2614 let idle_timeout = ConnectionParameters::default().get_idle_timeout();
2615 assert_eq!(client.process_output(now()).callback(), idle_timeout / 2);
2616 }
2617
2618 // Helper function: read response when a server sends HTTP_RESPONSE_2.
2619 fn read_response(
2620 client: &mut Http3Client,
2621 server: &mut Connection,
2622 request_stream_id: StreamId,
2623 ) {
2624 let out = server.process_output(now());
2625 client.process(out.dgram(), now());
2626
2627 while let Some(e) = client.next_event() {
2628 match e {
2629 Http3ClientEvent::HeaderReady {
2630 stream_id,
2631 headers,
2632 interim,
2633 fin,
2634 } => {
2635 assert_eq!(stream_id, request_stream_id);
2636 check_response_header_2(&headers);
2637 assert!(!fin);
2638 assert!(!interim);
2639 }
2640 Http3ClientEvent::DataReadable { stream_id } => {
2641 assert_eq!(stream_id, request_stream_id);
2642 let mut buf = [0_u8; 100];
2643 let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
2644 assert!(fin);
2645 assert_eq!(amount, EXPECTED_RESPONSE_DATA_2_FRAME_1.len());
2646 assert_eq!(&buf[..amount], EXPECTED_RESPONSE_DATA_2_FRAME_1);
2647 }
2648 _ => {}
2649 }
2650 }
2651
2652 // after this stream will be removed from client. We will check this by trying to read
2653 // from the stream and that should fail.
2654 let mut buf = [0_u8; 100];
2655 let res = client.read_data(now(), request_stream_id, &mut buf);
2656 assert!(res.is_err());
2657 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
2658
2659 client.close(now(), 0, "");
2660 }
2661
2662 // Data sent with a request:
2663 const REQUEST_BODY: &[u8] = &[0x64, 0x65, 0x66];
2664 // Corresponding data frame that server will receive.
2665 const EXPECTED_REQUEST_BODY_FRAME: &[u8] = &[0x0, 0x3, 0x64, 0x65, 0x66];
2666
2667 // Send a request with the request body.
2668 #[test]
2669 fn fetch_with_data() {
2670 // Connect exchange headers and send a request. Also check if the correct header frame has
2671 // been sent.
2672 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
2673
2674 // Get DataWritable for the request stream so that we can write the request body.
2675 let data_writable = |e| matches!(e, Http3ClientEvent::DataWritable { .. });
2676 assert!(client.events().any(data_writable));
2677 let sent = client.send_data(request_stream_id, REQUEST_BODY).unwrap();
2678 assert_eq!(sent, REQUEST_BODY.len());
2679 client.stream_close_send(request_stream_id).unwrap();
2680
2681 let out = client.process_output(now());
2682 drop(server.conn.process(out.dgram(), now()));
2683
2684 // find the new request/response stream and send response on it.
2685 while let Some(e) = server.conn.next_event() {
2686 match e {
2687 ConnectionEvent::NewStream { stream_id } => {
2688 assert_eq!(stream_id, request_stream_id);
2689 assert_eq!(stream_id.stream_type(), StreamType::BiDi);
2690 }
2691 ConnectionEvent::RecvStreamReadable { stream_id } => {
2692 assert_eq!(stream_id, request_stream_id);
2693
2694 // Read request body.
2695 let mut buf = [0_u8; 100];
2696 let (amount, fin) = server.conn.stream_recv(stream_id, &mut buf).unwrap();
2697 assert!(fin);
2698 assert_eq!(amount, EXPECTED_REQUEST_BODY_FRAME.len());
2699 assert_eq!(&buf[..amount], EXPECTED_REQUEST_BODY_FRAME);
2700
2701 // send response - 200 Content-Length: 3
2702 // with content: 'abc'.
2703 _ = server.conn.stream_send(stream_id, HTTP_RESPONSE_2).unwrap();
2704 server.conn.stream_close_send(stream_id).unwrap();
2705 }
2706 _ => {}
2707 }
2708 }
2709
2710 read_response(&mut client, &mut server.conn, request_stream_id);
2711 }
2712
2713 // send a request with request body containing request_body. We expect to receive
2714 // expected_data_frame_header.
2715 fn fetch_with_data_length_xbytes(request_body: &[u8], expected_data_frame_header: &[u8]) {
2716 // Connect exchange headers and send a request. Also check if the correct header frame has
2717 // been sent.
2718 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
2719
2720 // Get DataWritable for the request stream so that we can write the request body.
2721 let data_writable = |e| matches!(e, Http3ClientEvent::DataWritable { .. });
2722 assert!(client.events().any(data_writable));
2723 let sent = client.send_data(request_stream_id, request_body);
2724 assert_eq!(sent, Ok(request_body.len()));
2725
2726 // Close stream.
2727 client.stream_close_send(request_stream_id).unwrap();
2728
2729 // We need to loop a bit until all data has been sent.
2730 let mut out = client.process_output(now());
2731 for _i in 0..20 {
2732 out = server.conn.process(out.dgram(), now());
2733 out = client.process(out.dgram(), now());
2734 }
2735
2736 // check request body is received.
2737 // Then send a response.
2738 while let Some(e) = server.conn.next_event() {
2739 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
2740 if stream_id == request_stream_id {
2741 // Read the DATA frame.
2742 let mut buf = vec![1_u8; INITIAL_RECV_WINDOW_SIZE];
2743 let (amount, fin) = server.conn.stream_recv(stream_id, &mut buf).unwrap();
2744 assert!(fin);
2745 assert_eq!(
2746 amount,
2747 request_body.len() + expected_data_frame_header.len()
2748 );
2749
2750 // Check the DATA frame header
2751 assert_eq!(
2752 &buf[..expected_data_frame_header.len()],
2753 expected_data_frame_header
2754 );
2755
2756 // Check data.
2757 assert_eq!(&buf[expected_data_frame_header.len()..amount], request_body);
2758
2759 // send response - 200 Content-Length: 3
2760 // with content: 'abc'.
2761 _ = server.conn.stream_send(stream_id, HTTP_RESPONSE_2).unwrap();
2762 server.conn.stream_close_send(stream_id).unwrap();
2763 }
2764 }
2765 }
2766
2767 read_response(&mut client, &mut server.conn, request_stream_id);
2768 }
2769
2770 // send a request with 63 bytes. The DATA frame length field will still have 1 byte.
2771 #[test]
2772 fn fetch_with_data_length_63bytes() {
2773 fetch_with_data_length_xbytes(&[0_u8; 63], &[0x0, 0x3f]);
2774 }
2775
2776 // send a request with 64 bytes. The DATA frame length field will need 2 byte.
2777 #[test]
2778 fn fetch_with_data_length_64bytes() {
2779 fetch_with_data_length_xbytes(&[0_u8; 64], &[0x0, 0x40, 0x40]);
2780 }
2781
2782 // send a request with 16383 bytes. The DATA frame length field will still have 2 byte.
2783 #[test]
2784 fn fetch_with_data_length_16383bytes() {
2785 fetch_with_data_length_xbytes(&[0_u8; 16383], &[0x0, 0x7f, 0xff]);
2786 }
2787
2788 // send a request with 16384 bytes. The DATA frame length field will need 4 byte.
2789 #[test]
2790 fn fetch_with_data_length_16384bytes() {
2791 fetch_with_data_length_xbytes(&[0_u8; 16384], &[0x0, 0x80, 0x0, 0x40, 0x0]);
2792 }
2793
2794 // Send 2 data frames so that the second one cannot fit into the send_buf and it is only
2795 // partially sent. We check that the sent data is correct.
2796 fn fetch_with_two_data_frames(
2797 first_frame: &[u8],
2798 expected_first_data_frame_header: &[u8],
2799 expected_second_data_frame_header: &[u8],
2800 expected_second_data_frame: &[u8],
2801 ) {
2802 // Connect exchange headers and send a request. Also check if the correct header frame has
2803 // been sent.
2804 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
2805
2806 // Get DataWritable for the request stream so that we can write the request body.
2807 let data_writable = |e| matches!(e, Http3ClientEvent::DataWritable { .. });
2808 assert!(client.events().any(data_writable));
2809
2810 // Send the first frame.
2811 let sent = client.send_data(request_stream_id, first_frame);
2812 assert_eq!(sent, Ok(first_frame.len()));
2813
2814 // The second frame cannot fit.
2815 let sent = client.send_data(request_stream_id, &vec![0_u8; INITIAL_RECV_WINDOW_SIZE]);
2816 assert_eq!(sent, Ok(expected_second_data_frame.len()));
2817
2818 // Close stream.
2819 client.stream_close_send(request_stream_id).unwrap();
2820
2821 let mut out = client.process_output(now());
2822 // We need to loop a bit until all data has been sent. Once for every 1K
2823 // of data.
2824 for _i in 0..INITIAL_RECV_WINDOW_SIZE / 1000 {
2825 out = server.conn.process(out.dgram(), now());
2826 out = client.process(out.dgram(), now());
2827 }
2828
2829 // Check received frames and send a response.
2830 while let Some(e) = server.conn.next_event() {
2831 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
2832 if stream_id == request_stream_id {
2833 // Read DATA frames.
2834 let mut buf = vec![1_u8; INITIAL_RECV_WINDOW_SIZE];
2835 let (amount, fin) = server.conn.stream_recv(stream_id, &mut buf).unwrap();
2836 assert!(fin);
2837 assert_eq!(
2838 amount,
2839 expected_first_data_frame_header.len()
2840 + first_frame.len()
2841 + expected_second_data_frame_header.len()
2842 + expected_second_data_frame.len()
2843 );
2844
2845 // Check the first DATA frame header
2846 let end = expected_first_data_frame_header.len();
2847 assert_eq!(&buf[..end], expected_first_data_frame_header);
2848
2849 // Check the first frame data.
2850 let start = end;
2851 let end = end + first_frame.len();
2852 assert_eq!(&buf[start..end], first_frame);
2853
2854 // Check the second DATA frame header
2855 let start2 = end;
2856 let end2 = end + expected_second_data_frame_header.len();
2857 assert_eq!(&buf[start2..end2], expected_second_data_frame_header);
2858
2859 // Check the second frame data.
2860 let start3 = end2;
2861 let end3 = end2 + expected_second_data_frame.len();
2862 assert_eq!(&buf[start3..end3], expected_second_data_frame);
2863
2864 // send response - 200 Content-Length: 3
2865 // with content: 'abc'.
2866 _ = server.conn.stream_send(stream_id, HTTP_RESPONSE_2).unwrap();
2867 server.conn.stream_close_send(stream_id).unwrap();
2868 }
2869 }
2870 }
2871
2872 read_response(&mut client, &mut server.conn, request_stream_id);
2873 }
2874
2875 fn alloc_buffer(size: usize) -> (Vec<u8>, Vec<u8>) {
2876 let data_frame = HFrame::Data { len: size as u64 };
2877 let mut enc = Encoder::default();
2878 data_frame.encode(&mut enc);
2879
2880 (vec![0_u8; size], enc.as_ref().to_vec())
2881 }
2882
2883 // Send 2 frames. For the second one we can only send 63 bytes.
2884 // After the first frame there is exactly 63+2 bytes left in the send buffer.
2885 #[test]
2886 fn fetch_two_data_frame_second_63bytes() {
2887 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 88);
2888 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x3f], &[0_u8; 63]);
2889 }
2890
2891 // Send 2 frames. For the second one we can only send 63 bytes.
2892 // After the first frame there is exactly 63+3 bytes left in the send buffer,
2893 // but we can only send 63 bytes.
2894 #[test]
2895 fn fetch_two_data_frame_second_63bytes_place_for_66() {
2896 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 89);
2897 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x3f], &[0_u8; 63]);
2898 }
2899
2900 // Send 2 frames. For the second one we can only send 64 bytes.
2901 // After the first frame there is exactly 64+3 bytes left in the send buffer,
2902 // but we can only send 64 bytes.
2903 #[test]
2904 fn fetch_two_data_frame_second_64bytes_place_for_67() {
2905 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 90);
2906 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x40, 0x40], &[0_u8; 64]);
2907 }
2908
2909 // Send 2 frames. For the second one we can only send 16383 bytes.
2910 // After the first frame there is exactly 16383+3 bytes left in the send buffer.
2911 #[test]
2912 fn fetch_two_data_frame_second_16383bytes() {
2913 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 16409);
2914 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x7f, 0xff], &[0_u8; 16383]);
2915 }
2916
2917 // Send 2 frames. For the second one we can only send 16383 bytes.
2918 // After the first frame there is exactly 16383+4 bytes left in the send buffer, but we can only
2919 // send 16383 bytes.
2920 #[test]
2921 fn fetch_two_data_frame_second_16383bytes_place_for_16387() {
2922 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 16410);
2923 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x7f, 0xff], &[0_u8; 16383]);
2924 }
2925
2926 // Send 2 frames. For the second one we can only send 16383 bytes.
2927 // After the first frame there is exactly 16383+5 bytes left in the send buffer, but we can only
2928 // send 16383 bytes.
2929 #[test]
2930 fn fetch_two_data_frame_second_16383bytes_place_for_16388() {
2931 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 16411);
2932 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x7f, 0xff], &[0_u8; 16383]);
2933 }
2934
2935 // Send 2 frames. For the second one we can send 16384 bytes.
2936 // After the first frame there is exactly 16384+5 bytes left in the send buffer, but we can send
2937 // 16384 bytes.
2938 #[test]
2939 fn fetch_two_data_frame_second_16384bytes_place_for_16389() {
2940 let (buf, hdr) = alloc_buffer(INITIAL_RECV_WINDOW_SIZE - 16412);
2941 fetch_with_two_data_frames(&buf, &hdr, &[0x0, 0x80, 0x0, 0x40, 0x0], &[0_u8; 16384]);
2942 }
2943
2944 // Test receiving STOP_SENDING with the HttpNoError error code.
2945 #[test]
2946 fn stop_sending_early_response() {
2947 // Connect exchange headers and send a request. Also check if the correct header frame has
2948 // been sent.
2949 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
2950
2951 // Stop sending with early_response.
2952 assert_eq!(
2953 Ok(()),
2954 server
2955 .conn
2956 .stream_stop_sending(request_stream_id, Error::HttpNoError.code())
2957 );
2958
2959 // send response - 200 Content-Length: 3
2960 // with content: 'abc'.
2961 server_send_response_and_exchange_packet(
2962 &mut client,
2963 &mut server,
2964 request_stream_id,
2965 HTTP_RESPONSE_2,
2966 true,
2967 );
2968
2969 let mut stop_sending = false;
2970 let mut response_headers = false;
2971 let mut response_body = false;
2972 while let Some(e) = client.next_event() {
2973 match e {
2974 Http3ClientEvent::StopSending { stream_id, error } => {
2975 assert_eq!(stream_id, request_stream_id);
2976 assert_eq!(error, Error::HttpNoError.code());
2977 // assert that we cannot send any more request data.
2978 assert_eq!(
2979 Err(Error::InvalidStreamId),
2980 client.send_data(request_stream_id, &[0_u8; 10])
2981 );
2982 stop_sending = true;
2983 }
2984 Http3ClientEvent::HeaderReady {
2985 stream_id,
2986 headers,
2987 interim,
2988 fin,
2989 } => {
2990 assert_eq!(stream_id, request_stream_id);
2991 check_response_header_2(&headers);
2992 assert!(!fin);
2993 assert!(!interim);
2994 response_headers = true;
2995 }
2996 Http3ClientEvent::DataReadable { stream_id } => {
2997 assert_eq!(stream_id, request_stream_id);
2998 let mut buf = [0_u8; 100];
2999 let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
3000 assert!(fin);
3001 assert_eq!(amount, EXPECTED_RESPONSE_DATA_2_FRAME_1.len());
3002 assert_eq!(&buf[..amount], EXPECTED_RESPONSE_DATA_2_FRAME_1);
3003 response_body = true;
3004 }
3005 _ => {}
3006 }
3007 }
3008 assert!(response_headers);
3009 assert!(response_body);
3010 assert!(stop_sending);
3011
3012 // after this stream will be removed from client. We will check this by trying to read
3013 // from the stream and that should fail.
3014 let mut buf = [0_u8; 100];
3015 let res = client.read_data(now(), request_stream_id, &mut buf);
3016 assert!(res.is_err());
3017 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
3018
3019 client.close(now(), 0, "");
3020 }
3021
3022 // Server sends stop sending and reset.
3023 #[test]
3024 fn stop_sending_other_error_with_reset() {
3025 // Connect exchange headers and send a request. Also check if the correct header frame has
3026 // been sent.
3027 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
3028
3029 // Stop sending with RequestRejected.
3030 assert_eq!(
3031 Ok(()),
3032 server
3033 .conn
3034 .stream_stop_sending(request_stream_id, Error::HttpRequestRejected.code())
3035 );
3036 // also reset with RequestRejected.
3037 assert_eq!(
3038 Ok(()),
3039 server
3040 .conn
3041 .stream_reset_send(request_stream_id, Error::HttpRequestRejected.code())
3042 );
3043
3044 let out = server.conn.process_output(now());
3045 client.process(out.dgram(), now());
3046
3047 let mut reset = false;
3048 let mut stop_sending = false;
3049 while let Some(e) = client.next_event() {
3050 match e {
3051 Http3ClientEvent::StopSending { stream_id, error } => {
3052 assert_eq!(stream_id, request_stream_id);
3053 assert_eq!(error, Error::HttpRequestRejected.code());
3054 stop_sending = true;
3055 }
3056 Http3ClientEvent::Reset {
3057 stream_id,
3058 error,
3059 local,
3060 } => {
3061 assert_eq!(stream_id, request_stream_id);
3062 assert_eq!(error, Error::HttpRequestRejected.code());
3063 assert!(!local);
3064 reset = true;
3065 }
3066 Http3ClientEvent::HeaderReady { .. } | Http3ClientEvent::DataReadable { .. } => {
3067 panic!("We should not get any headers or data");
3068 }
3069 _ => {}
3070 }
3071 }
3072
3073 assert!(reset);
3074 assert!(stop_sending);
3075
3076 // after this stream will be removed from client. We will check this by trying to read
3077 // from the stream and that should fail.
3078 let mut buf = [0_u8; 100];
3079 let res = client.read_data(now(), request_stream_id, &mut buf);
3080 assert!(res.is_err());
3081 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
3082
3083 client.close(now(), 0, "");
3084 }
3085
3086 // Server sends stop sending with RequestRejected, but it does not send reset.
3087 #[test]
3088 fn stop_sending_other_error_wo_reset() {
3089 // Connect exchange headers and send a request. Also check if the correct header frame has
3090 // been sent.
3091 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
3092
3093 // Stop sending with RequestRejected.
3094 assert_eq!(
3095 Ok(()),
3096 server
3097 .conn
3098 .stream_stop_sending(request_stream_id, Error::HttpRequestRejected.code())
3099 );
3100
3101 let out = server.conn.process_output(now());
3102 client.process(out.dgram(), now());
3103
3104 let mut stop_sending = false;
3105
3106 while let Some(e) = client.next_event() {
3107 match e {
3108 Http3ClientEvent::StopSending { stream_id, error } => {
3109 assert_eq!(stream_id, request_stream_id);
3110 assert_eq!(error, Error::HttpRequestRejected.code());
3111 stop_sending = true;
3112 }
3113 Http3ClientEvent::Reset { .. } => {
3114 panic!("We should not get StopSending");
3115 }
3116 Http3ClientEvent::HeaderReady { .. } | Http3ClientEvent::DataReadable { .. } => {
3117 panic!("We should not get any headers or data");
3118 }
3119 _ => {}
3120 }
3121 }
3122
3123 assert!(stop_sending);
3124
3125 // after this we can still read from a stream.
3126 let mut buf = [0_u8; 100];
3127 let res = client.read_data(now(), request_stream_id, &mut buf);
3128 assert!(res.is_ok());
3129
3130 client.close(now(), 0, "");
3131 }
3132
3133 // Server sends stop sending and reset. We have some events for that stream already
3134 // in client.events. The events will be removed.
3135 #[test]
3136 fn stop_sending_and_reset_other_error_with_events() {
3137 // Connect exchange headers and send a request. Also check if the correct header frame has
3138 // been sent.
3139 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
3140
3141 // send response - 200 Content-Length: 3
3142 // with content: 'abc'.
3143 server_send_response_and_exchange_packet(
3144 &mut client,
3145 &mut server,
3146 request_stream_id,
3147 HTTP_RESPONSE_2,
3148 false,
3149 );
3150 // At this moment we have some new events, i.e. a HeadersReady event
3151
3152 // Send a stop sending and reset.
3153 assert_eq!(
3154 Ok(()),
3155 server
3156 .conn
3157 .stream_stop_sending(request_stream_id, Error::HttpRequestCancelled.code())
3158 );
3159 assert_eq!(
3160 Ok(()),
3161 server
3162 .conn
3163 .stream_reset_send(request_stream_id, Error::HttpRequestCancelled.code())
3164 );
3165
3166 let out = server.conn.process_output(now());
3167 client.process(out.dgram(), now());
3168
3169 let mut reset = false;
3170
3171 while let Some(e) = client.next_event() {
3172 match e {
3173 Http3ClientEvent::StopSending { stream_id, error } => {
3174 assert_eq!(stream_id, request_stream_id);
3175 assert_eq!(error, Error::HttpRequestCancelled.code());
3176 }
3177 Http3ClientEvent::Reset {
3178 stream_id,
3179 error,
3180 local,
3181 } => {
3182 assert_eq!(stream_id, request_stream_id);
3183 assert_eq!(error, Error::HttpRequestCancelled.code());
3184 assert!(!local);
3185 reset = true;
3186 }
3187 Http3ClientEvent::HeaderReady { .. } | Http3ClientEvent::DataReadable { .. } => {
3188 panic!("We should not get any headers or data");
3189 }
3190 _ => {}
3191 }
3192 }
3193
3194 assert!(reset);
3195
3196 // after this stream will be removed from client. We will check this by trying to read
3197 // from the stream and that should fail.
3198 let mut buf = [0_u8; 100];
3199 let res = client.read_data(now(), request_stream_id, &mut buf);
3200 assert!(res.is_err());
3201 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
3202
3203 client.close(now(), 0, "");
3204 }
3205
3206 // Server sends stop sending with code that is not HttpNoError.
3207 // We have some events for that stream already in the client.events.
3208 // The events will be removed.
3209 #[test]
3210 fn stop_sending_other_error_with_events() {
3211 // Connect exchange headers and send a request. Also check if the correct header frame has
3212 // been sent.
3213 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
3214
3215 // send response - 200 Content-Length: 3
3216 // with content: 'abc'.
3217 server_send_response_and_exchange_packet(
3218 &mut client,
3219 &mut server,
3220 request_stream_id,
3221 HTTP_RESPONSE_2,
3222 false,
3223 );
3224 // At this moment we have some new event, i.e. a HeadersReady event
3225
3226 // Send a stop sending.
3227 assert_eq!(
3228 Ok(()),
3229 server
3230 .conn
3231 .stream_stop_sending(request_stream_id, Error::HttpRequestCancelled.code())
3232 );
3233
3234 let out = server.conn.process_output(now());
3235 client.process(out.dgram(), now());
3236
3237 let mut stop_sending = false;
3238 let mut header_ready = false;
3239
3240 while let Some(e) = client.next_event() {
3241 match e {
3242 Http3ClientEvent::StopSending { stream_id, error } => {
3243 assert_eq!(stream_id, request_stream_id);
3244 assert_eq!(error, Error::HttpRequestCancelled.code());
3245 stop_sending = true;
3246 }
3247 Http3ClientEvent::Reset { .. } => {
3248 panic!("We should not get StopSending");
3249 }
3250 Http3ClientEvent::HeaderReady { .. } | Http3ClientEvent::DataReadable { .. } => {
3251 header_ready = true;
3252 }
3253 _ => {}
3254 }
3255 }
3256
3257 assert!(stop_sending);
3258 assert!(header_ready);
3259
3260 // after this, we can sill read data from a stream.
3261 let mut buf = [0_u8; 100];
3262 let (amount, fin) = client
3263 .read_data(now(), request_stream_id, &mut buf)
3264 .unwrap();
3265 assert!(!fin);
3266 assert_eq!(amount, EXPECTED_RESPONSE_DATA_2_FRAME_1.len());
3267 assert_eq!(&buf[..amount], EXPECTED_RESPONSE_DATA_2_FRAME_1);
3268
3269 client.close(now(), 0, "");
3270 }
3271
3272 // Server sends a reset. We will close sending side as well.
3273 #[test]
3274 fn reset_wo_stop_sending() {
3275 // Connect exchange headers and send a request. Also check if the correct header frame has
3276 // been sent.
3277 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
3278
3279 // Send a reset.
3280 assert_eq!(
3281 Ok(()),
3282 server
3283 .conn
3284 .stream_reset_send(request_stream_id, Error::HttpRequestCancelled.code())
3285 );
3286
3287 let out = server.conn.process_output(now());
3288 client.process(out.dgram(), now());
3289
3290 let mut reset = false;
3291
3292 while let Some(e) = client.next_event() {
3293 match e {
3294 Http3ClientEvent::StopSending { .. } => {
3295 panic!("We should not get StopSending");
3296 }
3297 Http3ClientEvent::Reset {
3298 stream_id,
3299 error,
3300 local,
3301 } => {
3302 assert_eq!(stream_id, request_stream_id);
3303 assert_eq!(error, Error::HttpRequestCancelled.code());
3304 assert!(!local);
3305 reset = true;
3306 }
3307 Http3ClientEvent::HeaderReady { .. } | Http3ClientEvent::DataReadable { .. } => {
3308 panic!("We should not get any headers or data");
3309 }
3310 _ => {}
3311 }
3312 }
3313
3314 assert!(reset);
3315
3316 // after this stream will be removed from client. We will check this by trying to read
3317 // from the stream and that should fail.
3318 let mut buf = [0_u8; 100];
3319 let res = client.read_data(now(), request_stream_id, &mut buf);
3320 assert!(res.is_err());
3321 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
3322
3323 client.close(now(), 0, "");
3324 }
3325
3326 fn test_incomplet_frame(buf: &[u8], error: &Error) {
3327 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3328
3329 server_send_response_and_exchange_packet(
3330 &mut client,
3331 &mut server,
3332 request_stream_id,
3333 buf,
3334 true,
3335 );
3336
3337 while let Some(e) = client.next_event() {
3338 if let Http3ClientEvent::DataReadable { stream_id } = e {
3339 assert_eq!(stream_id, request_stream_id);
3340 let mut buf_res = [0_u8; 100];
3341 let res = client.read_data(now(), stream_id, &mut buf_res);
3342 assert!(res.is_err());
3343 assert_eq!(res.unwrap_err(), Error::HttpFrame);
3344 }
3345 }
3346 assert_closed(&client, error);
3347 }
3348
3349 // Incomplete DATA frame
3350 #[test]
3351 fn incomplet_data_frame() {
3352 test_incomplet_frame(&HTTP_RESPONSE_2[..12], &Error::HttpFrame);
3353 }
3354
3355 // Incomplete HEADERS frame
3356 #[test]
3357 fn incomplet_headers_frame() {
3358 test_incomplet_frame(&HTTP_RESPONSE_2[..7], &Error::HttpFrame);
3359 }
3360
3361 #[test]
3362 fn incomplet_unknown_frame() {
3363 test_incomplet_frame(&[0x21], &Error::HttpFrame);
3364 }
3365
3366 // test goaway
3367 #[test]
3368 fn goaway() {
3369 let (mut client, mut server) = connect();
3370 let request_stream_id_1 = make_request(&mut client, false, &[]);
3371 assert_eq!(request_stream_id_1, 0);
3372 let request_stream_id_2 = make_request(&mut client, false, &[]);
3373 assert_eq!(request_stream_id_2, 4);
3374 let request_stream_id_3 = make_request(&mut client, false, &[]);
3375 assert_eq!(request_stream_id_3, 8);
3376
3377 let out = client.process_output(now());
3378 drop(server.conn.process(out.dgram(), now()));
3379
3380 _ = server
3381 .conn
3382 .stream_send(server.control_stream_id.unwrap(), &[0x7, 0x1, 0x8])
3383 .unwrap();
3384
3385 // find the new request/response stream and send frame v on it.
3386 while let Some(e) = server.conn.next_event() {
3387 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
3388 let mut buf = [0_u8; 100];
3389 _ = server.conn.stream_recv(stream_id, &mut buf).unwrap();
3390 if (stream_id == request_stream_id_1) || (stream_id == request_stream_id_2) {
3391 // send response - 200 Content-Length: 7
3392 // with content: 'abcdefg'.
3393 // The content will be send in 2 DATA frames.
3394 _ = server.conn.stream_send(stream_id, HTTP_RESPONSE_1).unwrap();
3395 server.conn.stream_close_send(stream_id).unwrap();
3396 }
3397 }
3398 }
3399 let out = server.conn.process_output(now());
3400 client.process(out.dgram(), now());
3401
3402 let mut stream_reset = false;
3403 while let Some(e) = client.next_event() {
3404 match e {
3405 Http3ClientEvent::HeaderReady { headers, fin, .. } => {
3406 check_response_header_1(&headers);
3407 assert!(!fin);
3408 }
3409 Http3ClientEvent::DataReadable { stream_id } => {
3410 assert!(
3411 (stream_id == request_stream_id_1) || (stream_id == request_stream_id_2)
3412 );
3413 let mut buf = [0_u8; 100];
3414 assert_eq!(
3415 (EXPECTED_RESPONSE_DATA_1.len(), true),
3416 client.read_data(now(), stream_id, &mut buf).unwrap()
3417 );
3418 }
3419 Http3ClientEvent::Reset {
3420 stream_id,
3421 error,
3422 local,
3423 } => {
3424 assert_eq!(stream_id, request_stream_id_3);
3425 assert_eq!(error, Error::HttpRequestRejected.code());
3426 assert!(!local);
3427 stream_reset = true;
3428 }
3429 _ => {}
3430 }
3431 }
3432
3433 assert!(stream_reset);
3434 assert_eq!(client.state(), Http3State::GoingAway(StreamId::new(8)));
3435
3436 // Check that a new request cannot be made.
3437 assert_eq!(
3438 client.fetch(
3439 now(),
3440 "GET",
3441 &("https", "something.com", "/"),
3442 &[],
3443 Priority::default()
3444 ),
3445 Err(Error::AlreadyClosed)
3446 );
3447
3448 client.close(now(), 0, "");
3449 }
3450
3451 #[test]
3452 fn multiple_goaways() {
3453 let (mut client, mut server) = connect();
3454 let request_stream_id_1 = make_request(&mut client, false, &[]);
3455 assert_eq!(request_stream_id_1, 0);
3456 let request_stream_id_2 = make_request(&mut client, false, &[]);
3457 assert_eq!(request_stream_id_2, 4);
3458 let request_stream_id_3 = make_request(&mut client, false, &[]);
3459 assert_eq!(request_stream_id_3, 8);
3460
3461 let out = client.process_output(now());
3462 drop(server.conn.process(out.dgram(), now()));
3463
3464 // First send a Goaway frame with an higher number
3465 _ = server
3466 .conn
3467 .stream_send(server.control_stream_id.unwrap(), &[0x7, 0x1, 0x8])
3468 .unwrap();
3469
3470 let out = server.conn.process_output(now());
3471 client.process(out.dgram(), now());
3472
3473 // Check that there is one reset for stream_id 8
3474 let mut stream_reset_1 = 0;
3475 while let Some(e) = client.next_event() {
3476 if let Http3ClientEvent::Reset {
3477 stream_id,
3478 error,
3479 local,
3480 } = e
3481 {
3482 assert_eq!(stream_id, request_stream_id_3);
3483 assert_eq!(error, Error::HttpRequestRejected.code());
3484 assert!(!local);
3485 stream_reset_1 += 1;
3486 }
3487 }
3488
3489 assert_eq!(stream_reset_1, 1);
3490 assert_eq!(client.state(), Http3State::GoingAway(StreamId::new(8)));
3491
3492 // Server sends another GOAWAY frame
3493 _ = server
3494 .conn
3495 .stream_send(server.control_stream_id.unwrap(), &[0x7, 0x1, 0x4])
3496 .unwrap();
3497
3498 // Send response for stream 0
3499 server_send_response_and_exchange_packet(
3500 &mut client,
3501 &mut server,
3502 request_stream_id_1,
3503 HTTP_RESPONSE_1,
3504 true,
3505 );
3506
3507 let mut stream_reset_2 = 0;
3508 while let Some(e) = client.next_event() {
3509 match e {
3510 Http3ClientEvent::HeaderReady { headers, fin, .. } => {
3511 check_response_header_1(&headers);
3512 assert!(!fin);
3513 }
3514 Http3ClientEvent::DataReadable { stream_id } => {
3515 assert!(stream_id == request_stream_id_1);
3516 let mut buf = [0_u8; 100];
3517 assert_eq!(
3518 (EXPECTED_RESPONSE_DATA_1.len(), true),
3519 client.read_data(now(), stream_id, &mut buf).unwrap()
3520 );
3521 }
3522 Http3ClientEvent::Reset {
3523 stream_id,
3524 error,
3525 local,
3526 } => {
3527 assert_eq!(stream_id, request_stream_id_2);
3528 assert_eq!(error, Error::HttpRequestRejected.code());
3529 assert!(!local);
3530 stream_reset_2 += 1;
3531 }
3532 _ => {}
3533 }
3534 }
3535
3536 assert_eq!(stream_reset_2, 1);
3537 assert_eq!(client.state(), Http3State::GoingAway(StreamId::new(4)));
3538 }
3539
3540 #[test]
3541 fn multiple_goaways_stream_id_increased() {
3542 let (mut client, mut server) = connect();
3543 let request_stream_id_1 = make_request(&mut client, false, &[]);
3544 assert_eq!(request_stream_id_1, 0);
3545 let request_stream_id_2 = make_request(&mut client, false, &[]);
3546 assert_eq!(request_stream_id_2, 4);
3547 let request_stream_id_3 = make_request(&mut client, false, &[]);
3548 assert_eq!(request_stream_id_3, 8);
3549
3550 // First send a Goaway frame with a smaller number
3551 _ = server
3552 .conn
3553 .stream_send(server.control_stream_id.unwrap(), &[0x7, 0x1, 0x4])
3554 .unwrap();
3555
3556 let out = server.conn.process_output(now());
3557 client.process(out.dgram(), now());
3558
3559 assert_eq!(client.state(), Http3State::GoingAway(StreamId::new(4)));
3560
3561 // Now send a Goaway frame with an higher number
3562 _ = server
3563 .conn
3564 .stream_send(server.control_stream_id.unwrap(), &[0x7, 0x1, 0x8])
3565 .unwrap();
3566
3567 let out = server.conn.process_output(now());
3568 client.process(out.dgram(), now());
3569
3570 assert_closed(&client, &Error::HttpGeneralProtocol);
3571 }
3572
3573 #[test]
3574 fn goaway_wrong_stream_id() {
3575 let (mut client, mut server) = connect();
3576
3577 _ = server
3578 .conn
3579 .stream_send(server.control_stream_id.unwrap(), &[0x7, 0x1, 0x9])
3580 .unwrap();
3581
3582 let out = server.conn.process_output(now());
3583 client.process(out.dgram(), now());
3584
3585 assert_closed(&client, &Error::HttpId);
3586 }
3587
3588 // Close stream before headers.
3589 #[test]
3590 fn stream_fin_wo_headers() {
3591 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3592 // send fin before sending any data.
3593 server.conn.stream_close_send(request_stream_id).unwrap();
3594
3595 let out = server.conn.process_output(now());
3596 client.process(out.dgram(), now());
3597
3598 // Recv HeaderReady without headers with fin.
3599 let e = client.events().next().unwrap();
3600 assert_eq!(
3601 e,
3602 Http3ClientEvent::Reset {
3603 stream_id: request_stream_id,
3604 error: Error::HttpGeneralProtocolStream.code(),
3605 local: true,
3606 }
3607 );
3608
3609 // Stream should now be closed and gone
3610 let mut buf = [0_u8; 100];
3611 assert_eq!(
3612 client.read_data(now(), StreamId::new(0), &mut buf),
3613 Err(Error::InvalidStreamId)
3614 );
3615 }
3616
3617 // Close stream immediately after headers.
3618 #[test]
3619 fn stream_fin_after_headers() {
3620 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3621
3622 server_send_response_and_exchange_packet(
3623 &mut client,
3624 &mut server,
3625 request_stream_id,
3626 HTTP_RESPONSE_HEADER_ONLY_2,
3627 true,
3628 );
3629
3630 // Recv HeaderReady with headers and fin.
3631 let e = client.events().next().unwrap();
3632 if let Http3ClientEvent::HeaderReady {
3633 stream_id,
3634 headers,
3635 interim,
3636 fin,
3637 } = e
3638 {
3639 assert_eq!(stream_id, request_stream_id);
3640 check_response_header_2(&headers);
3641 assert!(fin);
3642 assert!(!interim);
3643 } else {
3644 panic!("wrong event type");
3645 }
3646
3647 // Stream should now be closed and gone
3648 let mut buf = [0_u8; 100];
3649 assert_eq!(
3650 client.read_data(now(), StreamId::new(0), &mut buf),
3651 Err(Error::InvalidStreamId)
3652 );
3653 }
3654
3655 // Send headers, read headers and than close stream.
3656 // We should get HeaderReady and a DataReadable
3657 #[test]
3658 fn stream_fin_after_headers_are_read_wo_data_frame() {
3659 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3660 // Send some good data without fin
3661 server_send_response_and_exchange_packet(
3662 &mut client,
3663 &mut server,
3664 request_stream_id,
3665 HTTP_RESPONSE_HEADER_ONLY_2,
3666 false,
3667 );
3668
3669 // Recv headers without fin
3670 while let Some(e) = client.next_event() {
3671 match e {
3672 Http3ClientEvent::HeaderReady {
3673 stream_id,
3674 headers,
3675 interim,
3676 fin,
3677 } => {
3678 assert_eq!(stream_id, request_stream_id);
3679 check_response_header_2(&headers);
3680 assert!(!fin);
3681 assert!(!interim);
3682 }
3683 Http3ClientEvent::DataReadable { .. } => {
3684 panic!("We should not receive a DataGeadable event!");
3685 }
3686 _ => {}
3687 }
3688 }
3689
3690 // ok NOW send fin
3691 server.conn.stream_close_send(request_stream_id).unwrap();
3692
3693 let out = server.conn.process_output(now());
3694 client.process(out.dgram(), now());
3695
3696 // Recv DataReadable without data with fin
3697 while let Some(e) = client.next_event() {
3698 match e {
3699 Http3ClientEvent::HeaderReady { .. } => {
3700 panic!("We should not get another HeaderReady!");
3701 }
3702 Http3ClientEvent::DataReadable { stream_id } => {
3703 assert_eq!(stream_id, request_stream_id);
3704 let mut buf = [0_u8; 100];
3705 let res = client.read_data(now(), stream_id, &mut buf);
3706 let (len, fin) = res.expect("should read");
3707 assert_eq!(0, len);
3708 assert!(fin);
3709 }
3710 _ => {}
3711 }
3712 }
3713
3714 // Stream should now be closed and gone
3715 let mut buf = [0_u8; 100];
3716 assert_eq!(
3717 client.read_data(now(), StreamId::new(0), &mut buf),
3718 Err(Error::InvalidStreamId)
3719 );
3720 }
3721
3722 // Send headers and an empty data frame, then close the stream.
3723 #[test]
3724 fn stream_fin_after_headers_and_a_empty_data_frame() {
3725 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3726
3727 // Send headers.
3728 _ = server
3729 .conn
3730 .stream_send(request_stream_id, HTTP_RESPONSE_HEADER_ONLY_2)
3731 .unwrap();
3732 // Send an empty data frame.
3733 _ = server
3734 .conn
3735 .stream_send(request_stream_id, &[0x00, 0x00])
3736 .unwrap();
3737 // ok NOW send fin
3738 server.conn.stream_close_send(request_stream_id).unwrap();
3739
3740 let out = server.conn.process_output(now());
3741 client.process(out.dgram(), now());
3742
3743 // Recv HeaderReady with fin.
3744 while let Some(e) = client.next_event() {
3745 match e {
3746 Http3ClientEvent::HeaderReady {
3747 stream_id,
3748 headers,
3749 interim,
3750 fin,
3751 } => {
3752 assert_eq!(stream_id, request_stream_id);
3753 check_response_header_2(&headers);
3754 assert!(!fin);
3755 assert!(!interim);
3756 }
3757 Http3ClientEvent::DataReadable { stream_id } => {
3758 assert_eq!(stream_id, request_stream_id);
3759 let mut buf = [0_u8; 100];
3760 assert_eq!(Ok((0, true)), client.read_data(now(), stream_id, &mut buf));
3761 }
3762 _ => {}
3763 }
3764 }
3765
3766 // Stream should now be closed and gone
3767 let mut buf = [0_u8; 100];
3768 assert_eq!(
3769 client.read_data(now(), request_stream_id, &mut buf),
3770 Err(Error::InvalidStreamId)
3771 );
3772 }
3773
3774 // Send headers and an empty data frame. Read headers and then close the stream.
3775 // We should get a HeaderReady without fin and a DataReadable without data and with fin.
3776 #[test]
3777 fn stream_fin_after_headers_an_empty_data_frame_are_read() {
3778 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3779 // Send some good data without fin
3780 // Send headers.
3781 _ = server
3782 .conn
3783 .stream_send(request_stream_id, HTTP_RESPONSE_HEADER_ONLY_2)
3784 .unwrap();
3785 // Send an empty data frame.
3786 _ = server
3787 .conn
3788 .stream_send(request_stream_id, &[0x00, 0x00])
3789 .unwrap();
3790
3791 let out = server.conn.process_output(now());
3792 client.process(out.dgram(), now());
3793
3794 // Recv headers without fin
3795 while let Some(e) = client.next_event() {
3796 match e {
3797 Http3ClientEvent::HeaderReady {
3798 stream_id,
3799 headers,
3800 interim,
3801 fin,
3802 } => {
3803 assert_eq!(stream_id, request_stream_id);
3804 check_response_header_2(&headers);
3805 assert!(!fin);
3806 assert!(!interim);
3807 }
3808 Http3ClientEvent::DataReadable { .. } => {
3809 panic!("We should not receive a DataGeadable event!");
3810 }
3811 _ => {}
3812 }
3813 }
3814
3815 // ok NOW send fin
3816 server.conn.stream_close_send(request_stream_id).unwrap();
3817
3818 let out = server.conn.process_output(now());
3819 client.process(out.dgram(), now());
3820
3821 // Recv no data, but do get fin
3822 while let Some(e) = client.next_event() {
3823 match e {
3824 Http3ClientEvent::HeaderReady { .. } => {
3825 panic!("We should not get another HeaderReady!");
3826 }
3827 Http3ClientEvent::DataReadable { stream_id } => {
3828 assert_eq!(stream_id, request_stream_id);
3829 let mut buf = [0_u8; 100];
3830 let res = client.read_data(now(), stream_id, &mut buf);
3831 let (len, fin) = res.expect("should read");
3832 assert_eq!(0, len);
3833 assert!(fin);
3834 }
3835 _ => {}
3836 }
3837 }
3838
3839 // Stream should now be closed and gone
3840 let mut buf = [0_u8; 100];
3841 assert_eq!(
3842 client.read_data(now(), StreamId::new(0), &mut buf),
3843 Err(Error::InvalidStreamId)
3844 );
3845 }
3846
3847 #[test]
3848 fn stream_fin_after_a_data_frame() {
3849 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3850 // Send some good data without fin
3851 server_send_response_and_exchange_packet(
3852 &mut client,
3853 &mut server,
3854 request_stream_id,
3855 HTTP_RESPONSE_2,
3856 false,
3857 );
3858
3859 // Recv some good data without fin
3860 while let Some(e) = client.next_event() {
3861 match e {
3862 Http3ClientEvent::HeaderReady {
3863 stream_id,
3864 headers,
3865 interim,
3866 fin,
3867 } => {
3868 assert_eq!(stream_id, request_stream_id);
3869 check_response_header_2(&headers);
3870 assert!(!fin);
3871 assert!(!interim);
3872 }
3873 Http3ClientEvent::DataReadable { stream_id } => {
3874 assert_eq!(stream_id, request_stream_id);
3875 let mut buf = [0_u8; 100];
3876 let res = client.read_data(now(), stream_id, &mut buf);
3877 let (len, fin) = res.expect("should have data");
3878 assert_eq!(len, EXPECTED_RESPONSE_DATA_2_FRAME_1.len());
3879 assert_eq!(&buf[..len], EXPECTED_RESPONSE_DATA_2_FRAME_1);
3880 assert!(!fin);
3881 }
3882 _ => {}
3883 }
3884 }
3885
3886 // ok NOW send fin
3887 server.conn.stream_close_send(request_stream_id).unwrap();
3888 let out = server.conn.process_output(now());
3889 client.process(out.dgram(), now());
3890
3891 // fin without data should generate DataReadable
3892 let e = client.events().next().unwrap();
3893 if let Http3ClientEvent::DataReadable { stream_id } = e {
3894 assert_eq!(stream_id, request_stream_id);
3895 let mut buf = [0; 100];
3896 let res = client.read_data(now(), stream_id, &mut buf);
3897 let (len, fin) = res.expect("should read");
3898 assert_eq!(0, len);
3899 assert!(fin);
3900 } else {
3901 panic!("wrong event type");
3902 }
3903
3904 // Stream should now be closed and gone
3905 let mut buf = [0_u8; 100];
3906 assert_eq!(
3907 client.read_data(now(), StreamId::new(0), &mut buf),
3908 Err(Error::InvalidStreamId)
3909 );
3910 }
3911
3912 #[test]
3913 fn multiple_data_frames() {
3914 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3915
3916 // Send two data frames with fin
3917 server_send_response_and_exchange_packet(
3918 &mut client,
3919 &mut server,
3920 request_stream_id,
3921 HTTP_RESPONSE_1,
3922 true,
3923 );
3924
3925 // Read first frame
3926 match client.events().nth(1).unwrap() {
3927 Http3ClientEvent::DataReadable { stream_id } => {
3928 assert_eq!(stream_id, request_stream_id);
3929 let mut buf = [0_u8; 100];
3930 assert_eq!(
3931 (EXPECTED_RESPONSE_DATA_1.len(), true),
3932 client.read_data(now(), stream_id, &mut buf).unwrap()
3933 );
3934 }
3935 x => {
3936 panic!("event {x:?}");
3937 }
3938 }
3939
3940 // Stream should now be closed and gone
3941 let mut buf = [0_u8; 100];
3942 assert_eq!(
3943 client.read_data(now(), StreamId::new(0), &mut buf),
3944 Err(Error::InvalidStreamId)
3945 );
3946 }
3947
3948 #[test]
3949 fn receive_grease_before_response() {
3950 // Construct an unknown frame.
3951 const UNKNOWN_FRAME_LEN: usize = 832;
3952
3953 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3954
3955 let mut enc = Encoder::with_capacity(UNKNOWN_FRAME_LEN + 4);
3956 enc.encode_varint(1028_u64); // Arbitrary type.
3957 enc.encode_varint(UNKNOWN_FRAME_LEN as u64);
3958 let mut buf: Vec<_> = enc.into();
3959 buf.resize(UNKNOWN_FRAME_LEN + buf.len(), 0);
3960 _ = server.conn.stream_send(request_stream_id, &buf).unwrap();
3961
3962 // Send a headers and a data frame with fin
3963 server_send_response_and_exchange_packet(
3964 &mut client,
3965 &mut server,
3966 request_stream_id,
3967 HTTP_RESPONSE_2,
3968 true,
3969 );
3970
3971 // Read first frame
3972 match client.events().nth(1).unwrap() {
3973 Http3ClientEvent::DataReadable { stream_id } => {
3974 assert_eq!(stream_id, request_stream_id);
3975 let mut buf = [0_u8; 100];
3976 let (len, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
3977 assert_eq!(len, EXPECTED_RESPONSE_DATA_2_FRAME_1.len());
3978 assert_eq!(&buf[..len], EXPECTED_RESPONSE_DATA_2_FRAME_1);
3979 assert!(fin);
3980 }
3981 x => {
3982 panic!("event {x:?}");
3983 }
3984 }
3985 // Stream should now be closed and gone
3986 let mut buf = [0_u8; 100];
3987 assert_eq!(
3988 client.read_data(now(), StreamId::new(0), &mut buf),
3989 Err(Error::InvalidStreamId)
3990 );
3991 }
3992
3993 #[test]
3994 fn read_frames_header_blocked() {
3995 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
3996
3997 setup_server_side_encoder(&mut client, &mut server);
3998
3999 let headers = vec![
4000 Header::new(":status", "200"),
4001 Header::new("my-header", "my-header"),
4002 Header::new("content-length", "3"),
4003 ];
4004 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
4005 &mut server.conn,
4006 &headers,
4007 request_stream_id,
4008 );
4009 let hframe = HFrame::Headers {
4010 header_block: encoded_headers.to_vec(),
4011 };
4012
4013 // Send the encoder instructions, but delay them so that the stream is blocked on decoding
4014 // headers.
4015 let encoder_inst_pkt = server.conn.process_output(now());
4016
4017 // Send response
4018 let mut d = Encoder::default();
4019 hframe.encode(&mut d);
4020 let d_frame = HFrame::Data { len: 3 };
4021 d_frame.encode(&mut d);
4022 d.encode(&[0x61, 0x62, 0x63]);
4023 server_send_response_and_exchange_packet(
4024 &mut client,
4025 &mut server,
4026 request_stream_id,
4027 &d,
4028 true,
4029 );
4030
4031 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
4032 assert!(!client.events().any(header_ready_event));
4033
4034 // Let client receive the encoder instructions.
4035 drop(client.process(encoder_inst_pkt.dgram(), now()));
4036
4037 let out = server.conn.process_output(now());
4038 drop(client.process(out.dgram(), now()));
4039 drop(client.process_output(now()));
4040
4041 let mut recv_header = false;
4042 let mut recv_data = false;
4043 // Now the stream is unblocked and both headers and data will be consumed.
4044 while let Some(e) = client.next_event() {
4045 match e {
4046 Http3ClientEvent::HeaderReady { stream_id, .. } => {
4047 assert_eq!(stream_id, request_stream_id);
4048 recv_header = true;
4049 }
4050 Http3ClientEvent::DataReadable { stream_id } => {
4051 recv_data = true;
4052 assert_eq!(stream_id, request_stream_id);
4053 }
4054 x => {
4055 panic!("event {x:?}");
4056 }
4057 }
4058 }
4059 assert!(recv_header && recv_data);
4060 }
4061
4062 #[test]
4063 fn read_frames_header_blocked_with_fin_after_headers() {
4064 let (mut hconn, mut server, request_stream_id) = connect_and_send_request(true);
4065
4066 setup_server_side_encoder(&mut hconn, &mut server);
4067
4068 let sent_headers = vec![
4069 Header::new(":status", "200"),
4070 Header::new("my-header", "my-header"),
4071 Header::new("content-length", "0"),
4072 ];
4073 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
4074 &mut server.conn,
4075 &sent_headers,
4076 request_stream_id,
4077 );
4078 let hframe = HFrame::Headers {
4079 header_block: encoded_headers.to_vec(),
4080 };
4081
4082 // Send the encoder instructions, but delay them so that the stream is blocked on decoding
4083 // headers.
4084 let encoder_inst_pkt = server.conn.process_output(now());
4085
4086 let mut d = Encoder::default();
4087 hframe.encode(&mut d);
4088
4089 server_send_response_and_exchange_packet(
4090 &mut hconn,
4091 &mut server,
4092 request_stream_id,
4093 &d,
4094 true,
4095 );
4096
4097 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
4098 assert!(!hconn.events().any(header_ready_event));
4099
4100 // Let client receive the encoder instructions.
4101 let _out = hconn.process(encoder_inst_pkt.dgram(), now());
4102
4103 let mut recv_header = false;
4104 // Now the stream is unblocked. After headers we will receive a fin.
4105 while let Some(e) = hconn.next_event() {
4106 if let Http3ClientEvent::HeaderReady {
4107 stream_id,
4108 headers,
4109 interim,
4110 fin,
4111 } = e
4112 {
4113 assert_eq!(stream_id, request_stream_id);
4114 assert_eq!(headers.as_ref(), sent_headers);
4115 assert!(fin);
4116 assert!(!interim);
4117 recv_header = true;
4118 } else {
4119 panic!("event {e:?}");
4120 }
4121 }
4122 assert!(recv_header);
4123 }
4124
4125 fn exchange_token(client: &mut Http3Client, server: &mut Connection) -> ResumptionToken {
4126 server.send_ticket(now(), &[]).expect("can send ticket");
4127 let out = server.process_output(now());
4128 assert!(out.as_dgram_ref().is_some());
4129 client.process_input(out.dgram().unwrap(), now());
4130 // We do not have a token so we need to wait for a resumption token timer to trigger.
4131 client.process_output(now() + Duration::from_millis(250));
4132 assert_eq!(client.state(), Http3State::Connected);
4133 client
4134 .events()
4135 .find_map(|e| {
4136 if let Http3ClientEvent::ResumptionToken(token) = e {
4137 Some(token)
4138 } else {
4139 None
4140 }
4141 })
4142 .unwrap()
4143 }
4144
4145 fn start_with_0rtt() -> (Http3Client, TestServer) {
4146 let (mut client, mut server) = connect();
4147 let token = exchange_token(&mut client, &mut server.conn);
4148
4149 let mut client = default_http3_client();
4150
4151 let server = TestServer::new();
4152
4153 assert_eq!(client.state(), Http3State::Initializing);
4154 client
4155 .enable_resumption(now(), &token)
4156 .expect("Set resumption token");
4157
4158 assert_eq!(client.state(), Http3State::ZeroRtt);
4159 let zerortt_event = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::ZeroRtt));
4160 assert!(client.events().any(zerortt_event));
4161
4162 (client, server)
4163 }
4164
4165 #[test]
4166 fn zero_rtt_negotiated() {
4167 let (mut client, mut server) = start_with_0rtt();
4168
4169 let out = client.process_output(now());
4170 let out2 = client.process_output(now());
4171
4172 assert_eq!(client.state(), Http3State::ZeroRtt);
4173 assert_eq!(*server.conn.state(), State::Init);
4174 server.conn.process_input(out.dgram().unwrap(), now());
4175 let out = server.conn.process(out2.dgram(), now());
4176
4177 // Check that control and qpack streams are received and a
4178 // SETTINGS frame has been received.
4179 // Also qpack encoder stream will send "change capacity" instruction because it has
4180 // the peer settings already.
4181 server.check_control_qpack_request_streams_resumption(
4182 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4183 EXPECTED_REQUEST_HEADER_FRAME,
4184 false,
4185 );
4186
4187 assert_eq!(*server.conn.state(), State::Handshaking);
4188 let out = client.process(out.dgram(), now());
4189 let out = server.conn.process(out.dgram(), now());
4190 let out = client.process(out.dgram(), now());
4191 assert_eq!(client.state(), Http3State::Connected);
4192
4193 drop(server.conn.process(out.dgram(), now()));
4194 assert!(server.conn.state().connected());
4195
4196 assert!(client.tls_info().unwrap().resumed());
4197 assert!(server.conn.tls_info().unwrap().resumed());
4198 }
4199
4200 #[test]
4201 fn zero_rtt_send_request() {
4202 let (mut client, mut server) = start_with_0rtt();
4203
4204 let request_stream_id =
4205 make_request(&mut client, true, &[Header::new("myheaders", "myvalue")]);
4206 assert_eq!(request_stream_id, 0);
4207
4208 let out = client.process_output(now());
4209 let out2 = client.process_output(now());
4210
4211 assert_eq!(client.state(), Http3State::ZeroRtt);
4212 assert_eq!(*server.conn.state(), State::Init);
4213 server.conn.process_input(out.dgram().unwrap(), now());
4214 let out = server.conn.process(out2.dgram(), now());
4215
4216 // Check that control and qpack streams are received and a
4217 // SETTINGS frame has been received.
4218 // Also qpack encoder stream will send "change capacity" instruction because it has
4219 // the peer settings already.
4220 server.check_control_qpack_request_streams_resumption(
4221 ENCODER_STREAM_DATA_WITH_CAP_INST_AND_ENCODING_INST,
4222 EXPECTED_REQUEST_HEADER_FRAME_VERSION2,
4223 true,
4224 );
4225
4226 assert_eq!(*server.conn.state(), State::Handshaking);
4227 let out = client.process(out.dgram(), now());
4228 let out = server.conn.process(out.dgram(), now());
4229 let out = client.process(out.dgram(), now());
4230 assert_eq!(client.state(), Http3State::Connected);
4231 let out = server.conn.process(out.dgram(), now());
4232 assert!(server.conn.state().connected());
4233 let out = client.process(out.dgram(), now());
4234 assert!(out.dgram().is_none());
4235
4236 // After the server has been connected, send a response.
4237 let res = server.conn.stream_send(request_stream_id, HTTP_RESPONSE_2);
4238 assert_eq!(res, Ok(HTTP_RESPONSE_2.len()));
4239 server.conn.stream_close_send(request_stream_id).unwrap();
4240
4241 read_response(&mut client, &mut server.conn, request_stream_id);
4242
4243 assert!(client.tls_info().unwrap().resumed());
4244 assert!(server.conn.tls_info().unwrap().resumed());
4245 }
4246
4247 #[test]
4248 fn zero_rtt_before_resumption_token() {
4249 let mut client = default_http3_client();
4250 assert!(client
4251 .fetch(
4252 now(),
4253 "GET",
4254 &("https", "something.com", "/"),
4255 &[],
4256 Priority::default()
4257 )
4258 .is_err());
4259 }
4260
4261 #[test]
4262 fn zero_rtt_send_reject() {
4263 let (mut client, mut server) = connect();
4264 let token = exchange_token(&mut client, &mut server.conn);
4265
4266 let mut client = default_http3_client();
4267 let mut server = Connection::new_server(
4268 DEFAULT_KEYS,
4269 DEFAULT_ALPN_H3,
4270 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
4271 ConnectionParameters::default(),
4272 )
4273 .unwrap();
4274 // Using a freshly initialized anti-replay context
4275 // should result in the server rejecting 0-RTT.
4276 let ar = AntiReplay::new(now(), test_fixture::ANTI_REPLAY_WINDOW, 1, 3)
4277 .expect("setup anti-replay");
4278 server
4279 .server_enable_0rtt(&ar, AllowZeroRtt {})
4280 .expect("enable 0-RTT");
4281
4282 assert_eq!(client.state(), Http3State::Initializing);
4283 client
4284 .enable_resumption(now(), &token)
4285 .expect("Set resumption token");
4286 let zerortt_event = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::ZeroRtt));
4287 assert!(client.events().any(zerortt_event));
4288
4289 // Send ClientHello.
4290 let client_hs = client.process_output(now());
4291 assert!(client_hs.as_dgram_ref().is_some());
4292
4293 // Create a request
4294 let request_stream_id = make_request(&mut client, false, &[]);
4295 assert_eq!(request_stream_id, 0);
4296
4297 let client_0rtt = client.process_output(now());
4298 assert!(client_0rtt.as_dgram_ref().is_some());
4299
4300 server.process_input(client_hs.dgram().unwrap(), now());
4301 let server_hs = server.process(client_0rtt.dgram(), now());
4302 assert!(server_hs.as_dgram_ref().is_some()); // Should produce ServerHello etc...
4303
4304 let dgram = client.process(server_hs.dgram(), now()).dgram();
4305 let dgram = server.process(dgram, now());
4306
4307 // The server shouldn't receive that 0-RTT data.
4308 let recvd_stream_evt = |e| matches!(e, ConnectionEvent::NewStream { .. });
4309 assert!(!server.events().any(recvd_stream_evt));
4310
4311 // Client should get a rejection.
4312 let client_out = client.process(dgram.dgram(), now());
4313 assert!(client_out.as_dgram_ref().is_some());
4314 let recvd_0rtt_reject = |e| e == Http3ClientEvent::ZeroRttRejected;
4315 assert!(client.events().any(recvd_0rtt_reject));
4316
4317 // ...and the client stream should be gone.
4318 let res = client.stream_close_send(request_stream_id);
4319 assert!(res.is_err());
4320 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
4321
4322 // Client will send Setting frame and open new qpack streams.
4323 drop(server.process(client_out.dgram(), now()));
4324 TestServer::new_with_conn(server).check_client_control_qpack_streams_no_resumption();
4325
4326 // Check that we can send a request and that the stream_id starts again from 0.
4327 assert_eq!(make_request(&mut client, false, &[]), 0);
4328 }
4329
4330 // Connect to a server, get token and reconnect using 0-rtt. Server sends new Settings.
4331 fn zero_rtt_change_settings(
4332 original_settings: &[HSetting],
4333 resumption_settings: &[HSetting],
4334 expected_client_state: &Http3State,
4335 expected_encoder_stream_data: &[u8],
4336 ) {
4337 let mut client = default_http3_client();
4338 let mut server = TestServer::new_with_settings(original_settings);
4339 // Connect and get a token
4340 connect_with(&mut client, &mut server);
4341 let token = exchange_token(&mut client, &mut server.conn);
4342
4343 let mut client = default_http3_client();
4344 let mut server = TestServer::new_with_settings(resumption_settings);
4345 assert_eq!(client.state(), Http3State::Initializing);
4346 client
4347 .enable_resumption(now(), &token)
4348 .expect("Set resumption token");
4349 assert_eq!(client.state(), Http3State::ZeroRtt);
4350 let out = client.process_output(now());
4351 let out2 = client.process_output(now());
4352
4353 assert_eq!(client.state(), Http3State::ZeroRtt);
4354 assert_eq!(*server.conn.state(), State::Init);
4355 server.conn.process_input(out.dgram().unwrap(), now());
4356 let out = server.conn.process(out2.dgram(), now());
4357
4358 // Check that control and qpack streams and a SETTINGS frame are received.
4359 // Also qpack encoder stream will send "change capacity" instruction because it has
4360 // the peer settings already.
4361 server.check_control_qpack_request_streams_resumption(
4362 expected_encoder_stream_data,
4363 EXPECTED_REQUEST_HEADER_FRAME,
4364 false,
4365 );
4366
4367 assert_eq!(*server.conn.state(), State::Handshaking);
4368 let out = client.process(out.dgram(), now());
4369 let out = server.conn.process(out.dgram(), now());
4370 let out = client.process(out.dgram(), now());
4371 assert_eq!(client.state(), Http3State::Connected);
4372
4373 drop(server.conn.process(out.dgram(), now()));
4374 assert!(server.conn.state().connected());
4375
4376 assert!(client.tls_info().unwrap().resumed());
4377 assert!(server.conn.tls_info().unwrap().resumed());
4378
4379 // Send new settings.
4380 let control_stream = server.conn.stream_create(StreamType::UniDi).unwrap();
4381 let mut enc = Encoder::default();
4382 server.settings.encode(&mut enc);
4383 let mut sent = server.conn.stream_send(control_stream, CONTROL_STREAM_TYPE);
4384 assert_eq!(sent.unwrap(), CONTROL_STREAM_TYPE.len());
4385 sent = server.conn.stream_send(control_stream, enc.as_ref());
4386 assert_eq!(sent.unwrap(), enc.len());
4387
4388 let out = server.conn.process_output(now());
4389 client.process(out.dgram(), now());
4390
4391 assert_eq!(&client.state(), expected_client_state);
4392 assert!(server.conn.state().connected());
4393 }
4394
4395 #[test]
4396 fn zero_rtt_new_server_setting_are_the_same() {
4397 // Send a new server settings that are the same as the old one.
4398 zero_rtt_change_settings(
4399 &[
4400 HSetting::new(HSettingType::MaxTableCapacity, 100),
4401 HSetting::new(HSettingType::BlockedStreams, 100),
4402 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4403 ],
4404 &[
4405 HSetting::new(HSettingType::MaxTableCapacity, 100),
4406 HSetting::new(HSettingType::BlockedStreams, 100),
4407 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4408 ],
4409 &Http3State::Connected,
4410 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4411 );
4412 }
4413
4414 #[test]
4415 fn zero_rtt_new_server_setting_omit_max_table() {
4416 // Send a new server settings without MaxTableCapacity
4417 zero_rtt_change_settings(
4418 &[
4419 HSetting::new(HSettingType::MaxTableCapacity, 100),
4420 HSetting::new(HSettingType::BlockedStreams, 100),
4421 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4422 ],
4423 &[
4424 HSetting::new(HSettingType::BlockedStreams, 100),
4425 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4426 ],
4427 &Http3State::Closing(CloseReason::Application(265)),
4428 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4429 );
4430 }
4431
4432 #[test]
4433 fn zero_rtt_new_server_setting_omit_blocked_streams() {
4434 // Send a new server settings without BlockedStreams
4435 zero_rtt_change_settings(
4436 &[
4437 HSetting::new(HSettingType::MaxTableCapacity, 100),
4438 HSetting::new(HSettingType::BlockedStreams, 100),
4439 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4440 ],
4441 &[
4442 HSetting::new(HSettingType::MaxTableCapacity, 100),
4443 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4444 ],
4445 &Http3State::Closing(CloseReason::Application(265)),
4446 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4447 );
4448 }
4449
4450 #[test]
4451 fn zero_rtt_new_server_setting_omit_header_list_size() {
4452 // Send a new server settings without MaxHeaderListSize
4453 zero_rtt_change_settings(
4454 &[
4455 HSetting::new(HSettingType::MaxTableCapacity, 100),
4456 HSetting::new(HSettingType::BlockedStreams, 100),
4457 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4458 ],
4459 &[
4460 HSetting::new(HSettingType::MaxTableCapacity, 100),
4461 HSetting::new(HSettingType::BlockedStreams, 100),
4462 ],
4463 &Http3State::Connected,
4464 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4465 );
4466 }
4467
4468 #[test]
4469 fn zero_rtt_new_server_setting_max_table_size_bigger() {
4470 // Send a new server settings MaxTableCapacity=200
4471 zero_rtt_change_settings(
4472 &[
4473 HSetting::new(HSettingType::MaxTableCapacity, 100),
4474 HSetting::new(HSettingType::BlockedStreams, 100),
4475 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4476 ],
4477 &[
4478 HSetting::new(HSettingType::MaxTableCapacity, 200),
4479 HSetting::new(HSettingType::BlockedStreams, 100),
4480 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4481 ],
4482 &Http3State::Closing(CloseReason::Application(514)),
4483 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4484 );
4485 }
4486
4487 #[test]
4488 fn zero_rtt_new_server_setting_max_table_size_smaller() {
4489 // Send a new server settings MaxTableCapacity=50
4490 zero_rtt_change_settings(
4491 &[
4492 HSetting::new(HSettingType::MaxTableCapacity, 100),
4493 HSetting::new(HSettingType::BlockedStreams, 100),
4494 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4495 ],
4496 &[
4497 HSetting::new(HSettingType::MaxTableCapacity, 50),
4498 HSetting::new(HSettingType::BlockedStreams, 100),
4499 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4500 ],
4501 &Http3State::Closing(CloseReason::Application(265)),
4502 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4503 );
4504 }
4505
4506 #[test]
4507 fn zero_rtt_new_server_setting_blocked_streams_bigger() {
4508 // Send a new server settings withBlockedStreams=200
4509 zero_rtt_change_settings(
4510 &[
4511 HSetting::new(HSettingType::MaxTableCapacity, 100),
4512 HSetting::new(HSettingType::BlockedStreams, 100),
4513 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4514 ],
4515 &[
4516 HSetting::new(HSettingType::MaxTableCapacity, 100),
4517 HSetting::new(HSettingType::BlockedStreams, 200),
4518 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4519 ],
4520 &Http3State::Connected,
4521 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4522 );
4523 }
4524
4525 #[test]
4526 fn zero_rtt_new_server_setting_blocked_streams_smaller() {
4527 // Send a new server settings withBlockedStreams=50
4528 zero_rtt_change_settings(
4529 &[
4530 HSetting::new(HSettingType::MaxTableCapacity, 100),
4531 HSetting::new(HSettingType::BlockedStreams, 100),
4532 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4533 ],
4534 &[
4535 HSetting::new(HSettingType::MaxTableCapacity, 100),
4536 HSetting::new(HSettingType::BlockedStreams, 50),
4537 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4538 ],
4539 &Http3State::Closing(CloseReason::Application(265)),
4540 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4541 );
4542 }
4543
4544 #[test]
4545 fn zero_rtt_new_server_setting_max_header_size_bigger() {
4546 // Send a new server settings with MaxHeaderListSize=20000
4547 zero_rtt_change_settings(
4548 &[
4549 HSetting::new(HSettingType::MaxTableCapacity, 100),
4550 HSetting::new(HSettingType::BlockedStreams, 100),
4551 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4552 ],
4553 &[
4554 HSetting::new(HSettingType::MaxTableCapacity, 100),
4555 HSetting::new(HSettingType::BlockedStreams, 100),
4556 HSetting::new(HSettingType::MaxHeaderListSize, 20000),
4557 ],
4558 &Http3State::Connected,
4559 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4560 );
4561 }
4562
4563 #[test]
4564 fn zero_rtt_new_server_setting_max_headers_size_smaller() {
4565 // Send the new server settings with MaxHeaderListSize=5000
4566 zero_rtt_change_settings(
4567 &[
4568 HSetting::new(HSettingType::MaxTableCapacity, 100),
4569 HSetting::new(HSettingType::BlockedStreams, 100),
4570 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4571 ],
4572 &[
4573 HSetting::new(HSettingType::MaxTableCapacity, 100),
4574 HSetting::new(HSettingType::BlockedStreams, 100),
4575 HSetting::new(HSettingType::MaxHeaderListSize, 5000),
4576 ],
4577 &Http3State::Closing(CloseReason::Application(265)),
4578 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4579 );
4580 }
4581
4582 #[test]
4583 fn zero_rtt_max_table_size_first_omitted() {
4584 // send server original settings without MaxTableCapacity
4585 // send new server setting with MaxTableCapacity
4586 zero_rtt_change_settings(
4587 &[
4588 HSetting::new(HSettingType::BlockedStreams, 100),
4589 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4590 ],
4591 &[
4592 HSetting::new(HSettingType::MaxTableCapacity, 100),
4593 HSetting::new(HSettingType::BlockedStreams, 100),
4594 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4595 ],
4596 &Http3State::Connected,
4597 ENCODER_STREAM_DATA,
4598 );
4599 }
4600
4601 #[test]
4602 fn zero_rtt_blocked_streams_first_omitted() {
4603 // Send server original settings without BlockedStreams
4604 // Send the new server settings with BlockedStreams
4605 zero_rtt_change_settings(
4606 &[
4607 HSetting::new(HSettingType::MaxTableCapacity, 100),
4608 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4609 ],
4610 &[
4611 HSetting::new(HSettingType::MaxTableCapacity, 100),
4612 HSetting::new(HSettingType::BlockedStreams, 100),
4613 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4614 ],
4615 &Http3State::Connected,
4616 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4617 );
4618 }
4619
4620 #[test]
4621 fn zero_rtt_max_header_size_first_omitted() {
4622 // Send server settings without MaxHeaderListSize
4623 // Send new settings with MaxHeaderListSize.
4624 zero_rtt_change_settings(
4625 &[
4626 HSetting::new(HSettingType::MaxTableCapacity, 100),
4627 HSetting::new(HSettingType::BlockedStreams, 10000),
4628 ],
4629 &[
4630 HSetting::new(HSettingType::MaxTableCapacity, 100),
4631 HSetting::new(HSettingType::BlockedStreams, 100),
4632 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
4633 ],
4634 &Http3State::Closing(CloseReason::Application(265)),
4635 ENCODER_STREAM_DATA_WITH_CAP_INSTRUCTION,
4636 );
4637 }
4638
4639 #[test]
4640 fn trailers_with_fin_after_headers() {
4641 // Make a new connection.
4642 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
4643
4644 // Send HEADER frame.
4645 server_send_response_and_exchange_packet(
4646 &mut client,
4647 &mut server,
4648 request_stream_id,
4649 HTTP_HEADER_FRAME_0,
4650 false,
4651 );
4652
4653 // Check response headers.
4654 let mut response_headers = false;
4655 while let Some(e) = client.next_event() {
4656 if let Http3ClientEvent::HeaderReady {
4657 stream_id,
4658 headers,
4659 interim,
4660 fin,
4661 } = e
4662 {
4663 assert_eq!(stream_id, request_stream_id);
4664 check_response_header_0(&headers);
4665 assert!(!fin);
4666 assert!(!interim);
4667 response_headers = true;
4668 }
4669 }
4670 assert!(response_headers);
4671
4672 // Send trailers
4673 server_send_response_and_exchange_packet(
4674 &mut client,
4675 &mut server,
4676 request_stream_id,
4677 HTTP_HEADER_FRAME_0,
4678 true,
4679 );
4680
4681 let events: Vec<Http3ClientEvent> = client.events().collect();
4682
4683 // We already had HeaderReady
4684 let header_ready: fn(&Http3ClientEvent) -> _ =
4685 |e| matches!(*e, Http3ClientEvent::HeaderReady { .. });
4686 assert!(!events.iter().any(header_ready));
4687
4688 // Check that we have a DataReady event. Reading from the stream will return fin=true.
4689 let data_readable: fn(&Http3ClientEvent) -> _ =
4690 |e| matches!(*e, Http3ClientEvent::DataReadable { .. });
4691 assert!(events.iter().any(data_readable));
4692 let mut buf = [0_u8; 100];
4693 let (len, fin) = client
4694 .read_data(now(), request_stream_id, &mut buf)
4695 .unwrap();
4696 assert_eq!(0, len);
4697 assert!(fin);
4698 }
4699
4700 #[test]
4701 fn trailers_with_later_fin_after_headers() {
4702 // Make a new connection.
4703 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
4704
4705 // Send HEADER frame.
4706 server_send_response_and_exchange_packet(
4707 &mut client,
4708 &mut server,
4709 request_stream_id,
4710 HTTP_HEADER_FRAME_0,
4711 false,
4712 );
4713
4714 // Check response headers.
4715 let mut response_headers = false;
4716 while let Some(e) = client.next_event() {
4717 if let Http3ClientEvent::HeaderReady {
4718 stream_id,
4719 headers,
4720 interim,
4721 fin,
4722 } = e
4723 {
4724 assert_eq!(stream_id, request_stream_id);
4725 check_response_header_0(&headers);
4726 assert!(!fin);
4727 assert!(!interim);
4728 response_headers = true;
4729 }
4730 }
4731 assert!(response_headers);
4732
4733 // Send trailers
4734 server_send_response_and_exchange_packet(
4735 &mut client,
4736 &mut server,
4737 request_stream_id,
4738 HTTP_HEADER_FRAME_0,
4739 false,
4740 );
4741
4742 // Check that we do not have a DataReady event.
4743 let data_readable = |e| matches!(e, Http3ClientEvent::DataReadable { .. });
4744 assert!(!client.events().any(data_readable));
4745
4746 server.conn.stream_close_send(request_stream_id).unwrap();
4747
4748 let out = server.conn.process_output(now());
4749 client.process(out.dgram(), now());
4750
4751 let events: Vec<Http3ClientEvent> = client.events().collect();
4752
4753 // We already had HeaderReady
4754 let header_ready: fn(&Http3ClientEvent) -> _ =
4755 |e| matches!(*e, Http3ClientEvent::HeaderReady { .. });
4756 assert!(!events.iter().any(header_ready));
4757
4758 // Check that we have a DataReady event. Reading from the stream will return fin=true.
4759 let data_readable_fn: fn(&Http3ClientEvent) -> _ =
4760 |e| matches!(*e, Http3ClientEvent::DataReadable { .. });
4761 assert!(events.iter().any(data_readable_fn));
4762 let mut buf = [0_u8; 100];
4763 let (len, fin) = client
4764 .read_data(now(), request_stream_id, &mut buf)
4765 .unwrap();
4766 assert_eq!(0, len);
4767 assert!(fin);
4768 }
4769
4770 #[test]
4771 fn data_after_trailers_after_headers() {
4772 // Make a new connection.
4773 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
4774
4775 // Send HEADER frame.
4776 server_send_response_and_exchange_packet(
4777 &mut client,
4778 &mut server,
4779 request_stream_id,
4780 HTTP_HEADER_FRAME_0,
4781 false,
4782 );
4783
4784 // Check response headers.
4785 let mut response_headers = false;
4786 while let Some(e) = client.next_event() {
4787 if let Http3ClientEvent::HeaderReady {
4788 stream_id,
4789 headers,
4790 interim,
4791 fin,
4792 } = e
4793 {
4794 assert_eq!(stream_id, request_stream_id);
4795 check_response_header_0(&headers);
4796 assert!(!fin);
4797 assert!(!interim);
4798 response_headers = true;
4799 }
4800 }
4801 assert!(response_headers);
4802
4803 // Send trailers
4804 server_send_response_and_exchange_packet(
4805 &mut client,
4806 &mut server,
4807 request_stream_id,
4808 HTTP_HEADER_FRAME_0,
4809 false,
4810 );
4811
4812 // Check that we do not have a DataReady event.
4813 let data_readable = |e| matches!(e, Http3ClientEvent::DataReadable { .. });
4814 assert!(!client.events().any(data_readable));
4815
4816 // Send Data frame.
4817 server_send_response_and_exchange_packet(
4818 &mut client,
4819 &mut server,
4820 request_stream_id,
4821 [0x0, 0x3, 0x61, 0x62, 0x63], // a data frame
4822 false,
4823 );
4824
4825 assert_closed(&client, &Error::HttpFrameUnexpected);
4826 }
4827
4828 #[test]
4829 fn transport_stream_readable_event_after_all_data() {
4830 let (mut client, mut server, request_stream_id) = connect_and_send_request(false);
4831
4832 // Send headers.
4833 server_send_response_and_exchange_packet(
4834 &mut client,
4835 &mut server,
4836 request_stream_id,
4837 HTTP_RESPONSE_2,
4838 false,
4839 );
4840
4841 // Send an empty data frame and a fin
4842 server_send_response_and_exchange_packet(
4843 &mut client,
4844 &mut server,
4845 request_stream_id,
4846 [0x0, 0x0],
4847 true,
4848 );
4849
4850 let mut buf = [0_u8; 100];
4851 assert_eq!(
4852 client.read_data(now(), StreamId::new(0), &mut buf),
4853 Ok((3, true))
4854 );
4855
4856 client.process_output(now());
4857 }
4858
4859 #[test]
4860 fn no_data_ready_events_after_fin() {
4861 // Connect exchange headers and send a request. Also check if the correct header frame has
4862 // been sent.
4863 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
4864
4865 // send response - 200 Content-Length: 7
4866 // with content: 'abcdefg'.
4867 // The content will be send in 2 DATA frames.
4868 server_send_response_and_exchange_packet(
4869 &mut client,
4870 &mut server,
4871 request_stream_id,
4872 HTTP_RESPONSE_1,
4873 true,
4874 );
4875
4876 let data_readable_event = |e| matches!(e, Http3ClientEvent::DataReadable { stream_id } if stream_id == request_stream_id);
4877 assert!(client.events().any(data_readable_event));
4878
4879 let mut buf = [0_u8; 100];
4880 assert_eq!(
4881 (EXPECTED_RESPONSE_DATA_1.len(), true),
4882 client
4883 .read_data(now(), request_stream_id, &mut buf)
4884 .unwrap()
4885 );
4886
4887 assert!(!client.events().any(data_readable_event));
4888 }
4889
4890 #[test]
4891 fn reading_small_chunks_of_data() {
4892 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
4893
4894 // send response - 200 Content-Length: 7
4895 // with content: 'abcdefg'.
4896 // The content will be send in 2 DATA frames.
4897 server_send_response_and_exchange_packet(
4898 &mut client,
4899 &mut server,
4900 request_stream_id,
4901 HTTP_RESPONSE_1,
4902 true,
4903 );
4904
4905 let data_readable_event = |e| matches!(e, Http3ClientEvent::DataReadable { stream_id } if stream_id == request_stream_id);
4906 assert!(client.events().any(data_readable_event));
4907
4908 let mut buf1 = [0_u8; 1];
4909 assert_eq!(
4910 (1, false),
4911 client
4912 .read_data(now(), request_stream_id, &mut buf1)
4913 .unwrap()
4914 );
4915 assert!(!client.events().any(data_readable_event));
4916
4917 // Now read only until the end of the first frame. The firs frame has 3 bytes.
4918 let mut buf2 = [0_u8; 2];
4919 assert_eq!(
4920 (2, false),
4921 client
4922 .read_data(now(), request_stream_id, &mut buf2)
4923 .unwrap()
4924 );
4925 assert!(!client.events().any(data_readable_event));
4926
4927 // Read a half of the second frame.
4928 assert_eq!(
4929 (2, false),
4930 client
4931 .read_data(now(), request_stream_id, &mut buf2)
4932 .unwrap()
4933 );
4934 assert!(!client.events().any(data_readable_event));
4935
4936 // Read the rest.
4937 // Read a half of the second frame.
4938 assert_eq!(
4939 (2, true),
4940 client
4941 .read_data(now(), request_stream_id, &mut buf2)
4942 .unwrap()
4943 );
4944 assert!(!client.events().any(data_readable_event));
4945 }
4946
4947 #[test]
4948 fn zero_length_data_at_end() {
4949 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
4950
4951 // send response - 200 Content-Length: 7
4952 // with content: 'abcdefg'.
4953 // The content will be send in 2 DATA frames.
4954 server_send_response_and_exchange_packet(
4955 &mut client,
4956 &mut server,
4957 request_stream_id,
4958 HTTP_RESPONSE_1,
4959 false,
4960 );
4961 // Send a zero-length frame at the end of the stream.
4962 _ = server.conn.stream_send(request_stream_id, &[0, 0]).unwrap();
4963 server.conn.stream_close_send(request_stream_id).unwrap();
4964 let dgram = server.conn.process_output(now()).dgram();
4965 client.process_input(dgram.unwrap(), now());
4966
4967 let data_readable_event = |e: &_| matches!(e, Http3ClientEvent::DataReadable { stream_id } if *stream_id == request_stream_id);
4968 assert_eq!(client.events().filter(data_readable_event).count(), 1);
4969
4970 let mut buf = [0_u8; 10];
4971 assert_eq!(
4972 (7, true),
4973 client
4974 .read_data(now(), request_stream_id, &mut buf)
4975 .unwrap()
4976 );
4977 assert!(!client.events().any(|e| data_readable_event(&e)));
4978 }
4979
4980 #[test]
4981 fn stream_blocked_no_remote_encoder_stream() {
4982 let (mut client, mut server) = connect_only_transport();
4983
4984 send_and_receive_client_settings(&mut client, &mut server);
4985
4986 server.create_control_stream();
4987 // Send the server's control stream data.
4988 let out = server.conn.process_output(now());
4989 client.process(out.dgram(), now());
4990
4991 server.create_qpack_streams();
4992 let qpack_pkt1 = server.conn.process_output(now());
4993 // delay delivery of this packet.
4994
4995 let request_stream_id = make_request(&mut client, true, &[]);
4996 let out = client.process_output(now());
4997 drop(server.conn.process(out.dgram(), now()));
4998
4999 setup_server_side_encoder(&mut client, &mut server);
5000
5001 let headers = vec![
5002 Header::new(":status", "200"),
5003 Header::new("my-header", "my-header"),
5004 Header::new("content-length", "3"),
5005 ];
5006 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
5007 &mut server.conn,
5008 &headers,
5009 request_stream_id,
5010 );
5011 let hframe = HFrame::Headers {
5012 header_block: encoded_headers.to_vec(),
5013 };
5014
5015 // Send the encoder instructions,
5016 let out = server.conn.process_output(now());
5017 client.process(out.dgram(), now());
5018
5019 // Send response
5020 let mut d = Encoder::default();
5021 hframe.encode(&mut d);
5022 let d_frame = HFrame::Data { len: 3 };
5023 d_frame.encode(&mut d);
5024 d.encode(&[0x61, 0x62, 0x63]);
5025 _ = server
5026 .conn
5027 .stream_send(request_stream_id, d.as_ref())
5028 .unwrap();
5029 server.conn.stream_close_send(request_stream_id).unwrap();
5030
5031 let out = server.conn.process_output(now());
5032 drop(client.process(out.dgram(), now()));
5033
5034 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
5035 assert!(!client.events().any(header_ready_event));
5036
5037 // Let client receive the encoder instructions.
5038 drop(client.process(qpack_pkt1.dgram(), now()));
5039
5040 assert!(client.events().any(header_ready_event));
5041 }
5042
5043 // Client: receive a push stream
5044 #[test]
5045 fn push_single() {
5046 // Connect and send a request
5047 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5048
5049 // Send a push promise.
5050 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5051
5052 // create a push stream.
5053 _ = send_push_data(&mut server.conn, PushId::new(0), true);
5054
5055 server_send_response_and_exchange_packet(
5056 &mut client,
5057 &mut server,
5058 request_stream_id,
5059 HTTP_RESPONSE_2,
5060 true,
5061 );
5062
5063 read_response_and_push_events(
5064 &mut client,
5065 &[PushPromiseInfo {
5066 push_id: PushId::new(0),
5067 ref_stream_id: request_stream_id,
5068 }],
5069 &[PushId::new(0)],
5070 request_stream_id,
5071 );
5072
5073 assert_eq!(client.state(), Http3State::Connected);
5074
5075 // Check that the push has been closed, e.g. calling cancel_push should return
5076 // InvalidStreamId.
5077 assert_eq!(
5078 client.cancel_push(PushId::new(0)),
5079 Err(Error::InvalidStreamId)
5080 );
5081 }
5082
5083 /// We can't keep the connection alive on the basis of a push promise,
5084 /// nor do we want to if the push promise is not interesting to the client.
5085 /// We do the next best thing, which is keep any push stream alive if the
5086 /// client reads from it.
5087 #[test]
5088 fn push_keep_alive() {
5089 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5090 let idle_timeout = ConnectionParameters::default().get_idle_timeout();
5091
5092 // Promise a push and deliver, but don't close the stream.
5093 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5094 server_send_response_and_exchange_packet(
5095 &mut client,
5096 &mut server,
5097 request_stream_id,
5098 HTTP_RESPONSE_2,
5099 true,
5100 );
5101 read_response_and_push_events(
5102 &mut client,
5103 &[PushPromiseInfo {
5104 push_id: PushId::new(0),
5105 ref_stream_id: request_stream_id,
5106 }],
5107 &[], // No push streams yet.
5108 request_stream_id,
5109 );
5110
5111 // The client will become idle here.
5112 force_idle(&mut client, &mut server);
5113 assert_eq!(client.process_output(now()).callback(), idle_timeout);
5114
5115 // Reading push data will stop the client from being idle.
5116 _ = send_push_data(&mut server.conn, PushId::new(0), false);
5117 let out = server.conn.process_output(now());
5118 client.process_input(out.dgram().unwrap(), now());
5119
5120 let mut buf = [0; 16];
5121 let (read, fin) = client
5122 .push_read_data(now(), PushId::new(0), &mut buf)
5123 .unwrap();
5124 assert!(read < buf.len());
5125 assert!(!fin);
5126
5127 force_idle(&mut client, &mut server);
5128 assert_eq!(client.process_output(now()).callback(), idle_timeout / 2);
5129 }
5130
5131 #[test]
5132 fn push_multiple() {
5133 // Connect and send a request
5134 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5135
5136 // Send a push promise.
5137 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5138 send_push_promise(&mut server.conn, request_stream_id, PushId::new(1));
5139
5140 // create a push stream.
5141 _ = send_push_data(&mut server.conn, PushId::new(0), true);
5142
5143 // create a second push stream.
5144 _ = send_push_data(&mut server.conn, PushId::new(1), true);
5145
5146 server_send_response_and_exchange_packet(
5147 &mut client,
5148 &mut server,
5149 request_stream_id,
5150 HTTP_RESPONSE_2,
5151 true,
5152 );
5153
5154 read_response_and_push_events(
5155 &mut client,
5156 &[
5157 PushPromiseInfo {
5158 push_id: PushId::new(0),
5159 ref_stream_id: request_stream_id,
5160 },
5161 PushPromiseInfo {
5162 push_id: PushId::new(1),
5163 ref_stream_id: request_stream_id,
5164 },
5165 ],
5166 &[PushId::new(0), PushId::new(1)],
5167 request_stream_id,
5168 );
5169
5170 assert_eq!(client.state(), Http3State::Connected);
5171
5172 // Check that the push has been closed, e.g. calling cancel_push should return
5173 // InvalidStreamId.
5174 assert_eq!(
5175 client.cancel_push(PushId::new(0)),
5176 Err(Error::InvalidStreamId)
5177 );
5178 assert_eq!(
5179 client.cancel_push(PushId::new(1)),
5180 Err(Error::InvalidStreamId)
5181 );
5182 }
5183
5184 #[test]
5185 fn push_after_headers() {
5186 // Connect and send a request
5187 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5188
5189 // Send response headers
5190 _ = server
5191 .conn
5192 .stream_send(request_stream_id, HTTP_RESPONSE_HEADER_ONLY_2)
5193 .unwrap();
5194
5195 // Send a push promise.
5196 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5197
5198 // create a push stream.
5199 _ = send_push_data(&mut server.conn, PushId::new(0), true);
5200
5201 // Send response data
5202 server_send_response_and_exchange_packet(
5203 &mut client,
5204 &mut server,
5205 request_stream_id,
5206 HTTP_RESPONSE_DATA_FRAME_ONLY_2,
5207 true,
5208 );
5209
5210 read_response_and_push_events(
5211 &mut client,
5212 &[PushPromiseInfo {
5213 push_id: PushId::new(0),
5214 ref_stream_id: request_stream_id,
5215 }],
5216 &[PushId::new(0)],
5217 request_stream_id,
5218 );
5219
5220 assert_eq!(client.state(), Http3State::Connected);
5221 }
5222
5223 #[test]
5224 fn push_after_response() {
5225 // Connect and send a request
5226 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5227
5228 // Send response headers and data frames
5229 _ = server
5230 .conn
5231 .stream_send(request_stream_id, HTTP_RESPONSE_2)
5232 .unwrap();
5233
5234 // Send a push promise.
5235 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5236 // create a push stream.
5237 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), true);
5238
5239 read_response_and_push_events(
5240 &mut client,
5241 &[PushPromiseInfo {
5242 push_id: PushId::new(0),
5243 ref_stream_id: request_stream_id,
5244 }],
5245 &[PushId::new(0)],
5246 request_stream_id,
5247 );
5248
5249 assert_eq!(client.state(), Http3State::Connected);
5250 }
5251
5252 fn check_push_events(client: &mut Http3Client) -> bool {
5253 let any_push_event = |e| {
5254 matches!(
5255 e,
5256 Http3ClientEvent::PushPromise { .. }
5257 | Http3ClientEvent::PushHeaderReady { .. }
5258 | Http3ClientEvent::PushDataReadable { .. }
5259 )
5260 };
5261 client.events().any(any_push_event)
5262 }
5263
5264 fn check_data_readable(client: &mut Http3Client) -> bool {
5265 let any_data_event = |e| matches!(e, Http3ClientEvent::DataReadable { .. });
5266 client.events().any(any_data_event)
5267 }
5268
5269 fn check_header_ready(client: &mut Http3Client) -> bool {
5270 let any_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
5271 client.events().any(any_event)
5272 }
5273
5274 fn check_header_ready_and_push_promise(client: &mut Http3Client) -> bool {
5275 let any_event = |e| {
5276 matches!(
5277 e,
5278 Http3ClientEvent::HeaderReady { .. } | Http3ClientEvent::PushPromise { .. }
5279 )
5280 };
5281 client.events().any(any_event)
5282 }
5283
5284 #[test]
5285 fn push_stream_before_promise() {
5286 // Connect and send a request
5287 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5288
5289 // create a push stream.
5290 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), true);
5291
5292 // Assert that we do not have any push event.
5293 assert!(!check_push_events(&mut client));
5294
5295 // Now send push_promise
5296 send_push_promise_and_exchange_packets(
5297 &mut client,
5298 &mut server,
5299 request_stream_id,
5300 PushId::new(0),
5301 );
5302
5303 server_send_response_and_exchange_packet(
5304 &mut client,
5305 &mut server,
5306 request_stream_id,
5307 HTTP_RESPONSE_2,
5308 true,
5309 );
5310
5311 read_response_and_push_events(
5312 &mut client,
5313 &[PushPromiseInfo {
5314 push_id: PushId::new(0),
5315 ref_stream_id: request_stream_id,
5316 }],
5317 &[PushId::new(0)],
5318 request_stream_id,
5319 );
5320
5321 assert_eq!(client.state(), Http3State::Connected);
5322 }
5323
5324 // Test receiving pushes out of order.
5325 // Push_id 5 is received first, therefore Push_id 3 will be in the PushState:Init state.
5326 // Start push_id 3 by receiving a push_promise and then a push stream with the push_id 3.
5327 #[test]
5328 fn push_out_of_order_1() {
5329 // Connect and send a request
5330 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5331
5332 send_push_promise_and_exchange_packets(
5333 &mut client,
5334 &mut server,
5335 request_stream_id,
5336 PushId::new(5),
5337 );
5338
5339 send_push_promise_and_exchange_packets(
5340 &mut client,
5341 &mut server,
5342 request_stream_id,
5343 PushId::new(3),
5344 );
5345 // Start a push stream with push_id 3.
5346 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(3), true);
5347
5348 assert_eq!(client.state(), Http3State::Connected);
5349
5350 read_response_and_push_events(
5351 &mut client,
5352 &[
5353 PushPromiseInfo {
5354 push_id: PushId::new(5),
5355 ref_stream_id: request_stream_id,
5356 },
5357 PushPromiseInfo {
5358 push_id: PushId::new(3),
5359 ref_stream_id: request_stream_id,
5360 },
5361 ],
5362 &[PushId::new(3)],
5363 request_stream_id,
5364 );
5365 assert_eq!(client.state(), Http3State::Connected);
5366 }
5367
5368 // Test receiving pushes out of order.
5369 // Push_id 5 is received first, therefore Push_id 3 will be in the PushState:Init state.
5370 // Start push_id 3 by receiving a push stream with push_id 3 and then a push_promise.
5371 #[test]
5372 fn push_out_of_order_2() {
5373 // Connect and send a request
5374 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5375
5376 send_push_promise_and_exchange_packets(
5377 &mut client,
5378 &mut server,
5379 request_stream_id,
5380 PushId::new(5),
5381 );
5382
5383 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(3), true);
5384 send_push_promise_and_exchange_packets(
5385 &mut client,
5386 &mut server,
5387 request_stream_id,
5388 PushId::new(3),
5389 );
5390
5391 read_response_and_push_events(
5392 &mut client,
5393 &[
5394 PushPromiseInfo {
5395 push_id: PushId::new(5),
5396 ref_stream_id: request_stream_id,
5397 },
5398 PushPromiseInfo {
5399 push_id: PushId::new(3),
5400 ref_stream_id: request_stream_id,
5401 },
5402 ],
5403 &[PushId::new(3)],
5404 request_stream_id,
5405 );
5406 assert_eq!(client.state(), Http3State::Connected);
5407 }
5408
5409 // Test receiving pushes out of order.
5410 // Push_id 5 is received first and read so that it is removed from the list,
5411 // therefore Push_id 3 will be in the PushState:Init state.
5412 // Start push_id 3 by receiving a push stream with the push_id 3 and then a push_promise.
5413 #[test]
5414 fn push_out_of_order_3() {
5415 // Connect and send a request
5416 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5417
5418 send_push_promise_and_exchange_packets(
5419 &mut client,
5420 &mut server,
5421 request_stream_id,
5422 PushId::new(5),
5423 );
5424 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(5), true);
5425 assert_eq!(client.state(), Http3State::Connected);
5426
5427 // Read push stream with push_id 5 to make it change to closed state.
5428 read_response_and_push_events(
5429 &mut client,
5430 &[PushPromiseInfo {
5431 push_id: PushId::new(5),
5432 ref_stream_id: request_stream_id,
5433 }],
5434 &[PushId::new(5)],
5435 request_stream_id,
5436 );
5437
5438 send_push_promise_and_exchange_packets(
5439 &mut client,
5440 &mut server,
5441 request_stream_id,
5442 PushId::new(3),
5443 );
5444 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(3), true);
5445
5446 read_response_and_push_events(
5447 &mut client,
5448 &[PushPromiseInfo {
5449 push_id: PushId::new(3),
5450 ref_stream_id: request_stream_id,
5451 }],
5452 &[PushId::new(3)],
5453 request_stream_id,
5454 );
5455 assert_eq!(client.state(), Http3State::Connected);
5456 }
5457
5458 // The next test is for receiving a second PushPromise when Push is in the PushPromise state.
5459 #[test]
5460 fn multiple_push_promise() {
5461 // Connect and send a request
5462 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5463
5464 send_push_promise_and_exchange_packets(
5465 &mut client,
5466 &mut server,
5467 request_stream_id,
5468 PushId::new(5),
5469 );
5470
5471 // make a second request.
5472 let request_stream_id_2 = make_request(&mut client, false, &[]);
5473 assert_eq!(request_stream_id_2, 4);
5474
5475 let out = client.process_output(now());
5476 drop(server.conn.process(out.dgram(), now()));
5477
5478 send_push_promise_and_exchange_packets(
5479 &mut client,
5480 &mut server,
5481 request_stream_id_2,
5482 PushId::new(5),
5483 );
5484
5485 read_response_and_push_events(
5486 &mut client,
5487 &[
5488 PushPromiseInfo {
5489 push_id: PushId::new(5),
5490 ref_stream_id: request_stream_id,
5491 },
5492 PushPromiseInfo {
5493 push_id: PushId::new(5),
5494 ref_stream_id: request_stream_id_2,
5495 },
5496 ],
5497 &[],
5498 request_stream_id,
5499 );
5500 assert_eq!(client.state(), Http3State::Connected);
5501 }
5502
5503 // The next test is for receiving a second PushPromise when Push is in the Active state.
5504 #[test]
5505 fn multiple_push_promise_active() {
5506 // Connect and send a request
5507 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5508
5509 send_push_promise_and_exchange_packets(
5510 &mut client,
5511 &mut server,
5512 request_stream_id,
5513 PushId::new(5),
5514 );
5515 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(5), true);
5516
5517 // make a second request.
5518 let request_stream_id_2 = make_request(&mut client, false, &[]);
5519 assert_eq!(request_stream_id_2, 4);
5520
5521 let out = client.process_output(now());
5522 drop(server.conn.process(out.dgram(), now()));
5523
5524 send_push_promise_and_exchange_packets(
5525 &mut client,
5526 &mut server,
5527 request_stream_id_2,
5528 PushId::new(5),
5529 );
5530
5531 read_response_and_push_events(
5532 &mut client,
5533 &[
5534 PushPromiseInfo {
5535 push_id: PushId::new(5),
5536 ref_stream_id: request_stream_id,
5537 },
5538 PushPromiseInfo {
5539 push_id: PushId::new(5),
5540 ref_stream_id: request_stream_id_2,
5541 },
5542 ],
5543 &[PushId::new(5)],
5544 request_stream_id,
5545 );
5546 assert_eq!(client.state(), Http3State::Connected);
5547 }
5548
5549 // The next test is for receiving a second PushPromise when the push is already closed.
5550 // PushPromise will be ignored for the push streams that are consumed.
5551 #[test]
5552 fn multiple_push_promise_closed() {
5553 // Connect and send a request
5554 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5555
5556 send_push_promise_and_exchange_packets(
5557 &mut client,
5558 &mut server,
5559 request_stream_id,
5560 PushId::new(5),
5561 );
5562 // Start a push stream with push_id 5.
5563 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(5), true);
5564
5565 read_response_and_push_events(
5566 &mut client,
5567 &[PushPromiseInfo {
5568 push_id: PushId::new(5),
5569 ref_stream_id: request_stream_id,
5570 }],
5571 &[PushId::new(5)],
5572 request_stream_id,
5573 );
5574
5575 // make a second request.
5576 let request_stream_id_2 = make_request(&mut client, false, &[]);
5577 assert_eq!(request_stream_id_2, 4);
5578
5579 let out = client.process_output(now());
5580 drop(server.conn.process(out.dgram(), now()));
5581
5582 send_push_promise_and_exchange_packets(
5583 &mut client,
5584 &mut server,
5585 request_stream_id_2,
5586 PushId::new(5),
5587 );
5588
5589 // Check that we do not have a Http3ClientEvent::PushPromise.
5590 let push_event = |e| matches!(e, Http3ClientEvent::PushPromise { .. });
5591 assert!(!client.events().any(push_event));
5592 }
5593
5594 // Test that max_push_id is enforced when a push promise frame is received.
5595 #[test]
5596 fn exceed_max_push_id_promise() {
5597 // Connect and send a request
5598 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5599
5600 // Send a push promise. max_push_id is set to 5, to trigger an error we send push_id=6.
5601 send_push_promise_and_exchange_packets(
5602 &mut client,
5603 &mut server,
5604 request_stream_id,
5605 PushId::new(6),
5606 );
5607
5608 assert_closed(&client, &Error::HttpId);
5609 }
5610
5611 // Test that max_push_id is enforced when a push stream is received.
5612 #[test]
5613 fn exceed_max_push_id_push_stream() {
5614 // Connect and send a request
5615 let (mut client, mut server) = connect();
5616
5617 // Send a push stream. max_push_id is set to 5, to trigger an error we send push_id=6.
5618 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(6), true);
5619
5620 assert_closed(&client, &Error::HttpId);
5621 }
5622
5623 // Test that max_push_id is enforced when a cancel push frame is received.
5624 #[test]
5625 fn exceed_max_push_id_cancel_push() {
5626 // Connect and send a request
5627 let (mut client, mut server, _request_stream_id) = connect_and_send_request(true);
5628
5629 // Send CANCEL_PUSH for push_id 6.
5630 send_cancel_push_and_exchange_packets(&mut client, &mut server, PushId::new(6));
5631
5632 assert_closed(&client, &Error::HttpId);
5633 }
5634
5635 // Test that max_push_id is enforced when an app calls cancel_push.
5636 #[test]
5637 fn exceed_max_push_id_cancel_api() {
5638 // Connect and send a request
5639 let (mut client, _, _) = connect_and_send_request(true);
5640
5641 assert_eq!(client.cancel_push(PushId::new(6)), Err(Error::HttpId));
5642 assert_eq!(client.state(), Http3State::Connected);
5643 }
5644
5645 #[test]
5646 fn max_push_id_frame_update_is_sent() {
5647 const MAX_PUSH_ID_FRAME: &[u8] = &[0xd, 0x1, 0x8];
5648
5649 // Connect and send a request
5650 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5651
5652 // Send 3 push promises.
5653 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5654 send_push_promise(&mut server.conn, request_stream_id, PushId::new(1));
5655 send_push_promise(&mut server.conn, request_stream_id, PushId::new(2));
5656
5657 // create 3 push streams.
5658 send_push_data(&mut server.conn, PushId::new(0), true);
5659 send_push_data(&mut server.conn, PushId::new(1), true);
5660 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(2), true);
5661
5662 read_response_and_push_events(
5663 &mut client,
5664 &[
5665 PushPromiseInfo {
5666 push_id: PushId::new(0),
5667 ref_stream_id: request_stream_id,
5668 },
5669 PushPromiseInfo {
5670 push_id: PushId::new(1),
5671 ref_stream_id: request_stream_id,
5672 },
5673 PushPromiseInfo {
5674 push_id: PushId::new(2),
5675 ref_stream_id: request_stream_id,
5676 },
5677 ],
5678 &[PushId::new(0), PushId::new(1), PushId::new(2)],
5679 request_stream_id,
5680 );
5681
5682 let out = client.process_output(now());
5683 drop(server.conn.process(out.dgram(), now()));
5684
5685 // Check max_push_id frame has been received
5686 let control_stream_readable =
5687 |e| matches!(e, ConnectionEvent::RecvStreamReadable{stream_id: x} if x == 2);
5688 assert!(server.conn.events().any(control_stream_readable));
5689 let mut buf = [0_u8; 100];
5690 let (amount, fin) = server.conn.stream_recv(StreamId::new(2), &mut buf).unwrap();
5691 assert!(!fin);
5692
5693 assert_eq!(amount, MAX_PUSH_ID_FRAME.len());
5694 assert_eq!(&buf[..3], MAX_PUSH_ID_FRAME);
5695
5696 // Check that we can send push_id=8 now
5697 send_push_promise(&mut server.conn, request_stream_id, PushId::new(8));
5698 send_push_data(&mut server.conn, PushId::new(8), true);
5699
5700 let out = server.conn.process_output(now());
5701 let out = client.process(out.dgram(), now());
5702 drop(server.conn.process(out.dgram(), now()));
5703
5704 assert_eq!(client.state(), Http3State::Connected);
5705
5706 read_response_and_push_events(
5707 &mut client,
5708 &[PushPromiseInfo {
5709 push_id: PushId::new(8),
5710 ref_stream_id: request_stream_id,
5711 }],
5712 &[PushId::new(8)],
5713 request_stream_id,
5714 );
5715
5716 assert_eq!(client.state(), Http3State::Connected);
5717 }
5718
5719 // Test that 2 push streams with the same push_id are caught.
5720 #[test]
5721 fn duplicate_push_stream() {
5722 // Connect and send a request
5723 let (mut client, mut server, _request_stream_id) = connect_and_send_request(true);
5724
5725 // Start a push stream with push_id 0.
5726 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), true);
5727
5728 // Send it again
5729 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), true);
5730
5731 assert_closed(&client, &Error::HttpId);
5732 }
5733
5734 // Test that 2 push streams with the same push_id are caught.
5735 #[test]
5736 fn duplicate_push_stream_active() {
5737 // Connect and send a request
5738 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5739
5740 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5741 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), true);
5742 // Now the push_stream is in the PushState::Active state
5743
5744 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), true);
5745
5746 assert_closed(&client, &Error::HttpId);
5747 }
5748
5749 fn assert_stop_sending_event(
5750 server: &mut TestServer,
5751 push_stream_id: StreamId,
5752 expected_error: u64,
5753 ) {
5754 assert!(server.conn.events().any(|e| matches!(
5755 e,
5756 ConnectionEvent::SendStreamStopSending {
5757 stream_id,
5758 app_error,
5759 } if stream_id == push_stream_id && app_error == expected_error
5760 )));
5761 }
5762
5763 // Test CANCEL_PUSH frame: after cancel push any new PUSH_PROMISE or push stream will be
5764 // ignored.
5765 #[test]
5766 fn cancel_push_ignore_promise() {
5767 // Connect and send a request
5768 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5769
5770 send_cancel_push_and_exchange_packets(&mut client, &mut server, PushId::new(0));
5771
5772 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5773 // Start a push stream with push_id 0.
5774 let push_stream_id =
5775 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
5776
5777 // Assert that we do not have any push event.
5778 assert!(!check_push_events(&mut client));
5779
5780 // Check that the push has been closed, e.g. calling cancel_push should return
5781 // InvalidStreamId.
5782 assert_eq!(
5783 client.cancel_push(PushId::new(0)),
5784 Err(Error::InvalidStreamId)
5785 );
5786
5787 // Check that the push has been canceled by the client.
5788 assert_stop_sending_event(
5789 &mut server,
5790 push_stream_id,
5791 Error::HttpRequestCancelled.code(),
5792 );
5793
5794 assert_eq!(client.state(), Http3State::Connected);
5795 }
5796
5797 // Test CANCEL_PUSH frame: after cancel push any already received PUSH_PROMISE or push stream
5798 // events will be removed.
5799 #[test]
5800 fn cancel_push_removes_push_events() {
5801 // Connect and send a request
5802 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5803
5804 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5805 let push_stream_id =
5806 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
5807
5808 send_cancel_push_and_exchange_packets(&mut client, &mut server, PushId::new(0));
5809
5810 // Assert that we do not have any push event.
5811 assert!(!check_push_events(&mut client));
5812
5813 // Check that the push has been closed, e.g. calling cancel_push should return
5814 // InvalidStreamId.
5815 assert_eq!(
5816 client.cancel_push(PushId::new(0)),
5817 Err(Error::InvalidStreamId)
5818 );
5819
5820 // Check that the push has been canceled by the client.
5821 assert_stop_sending_event(
5822 &mut server,
5823 push_stream_id,
5824 Error::HttpRequestCancelled.code(),
5825 );
5826
5827 assert_eq!(client.state(), Http3State::Connected);
5828 }
5829
5830 // Test CANCEL_PUSH frame: after cancel push any already received push stream will be canceled.
5831 #[test]
5832 fn cancel_push_frame_after_push_stream() {
5833 // Connect and send a request
5834 let (mut client, mut server, _) = connect_and_send_request(true);
5835
5836 // Start a push stream with push_id 0.
5837 let push_stream_id =
5838 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
5839
5840 send_cancel_push_and_exchange_packets(&mut client, &mut server, PushId::new(0));
5841
5842 // Assert that we do not have any push event.
5843 assert!(!check_push_events(&mut client));
5844
5845 // Check that the push has been closed, e.g. calling cancel_push should return
5846 // InvalidStreamId.
5847 assert_eq!(
5848 client.cancel_push(PushId::new(0)),
5849 Err(Error::InvalidStreamId)
5850 );
5851
5852 // Check that the push has been canceled by the client.
5853 assert_stop_sending_event(
5854 &mut server,
5855 push_stream_id,
5856 Error::HttpRequestCancelled.code(),
5857 );
5858
5859 assert_eq!(client.state(), Http3State::Connected);
5860 }
5861
5862 // Test a push stream reset after a new PUSH_PROMISE or/and push stream. The events will be
5863 // ignored.
5864 #[test]
5865 fn cancel_push_stream_after_push_promise_and_push_stream() {
5866 // Connect and send a request
5867 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5868
5869 send_push_promise(&mut server.conn, request_stream_id, PushId::new(0));
5870 // Start a push stream with push_id 0.
5871 let push_stream_id =
5872 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
5873
5874 server
5875 .conn
5876 .stream_reset_send(push_stream_id, Error::HttpRequestCancelled.code())
5877 .unwrap();
5878 let out = server.conn.process_output(now());
5879 client.process(out.dgram(), now());
5880
5881 // Assert that we do not have any push event.
5882 assert!(!check_push_events(&mut client));
5883
5884 // Check that the push has been closed, e.g. calling cancel_push should return
5885 // InvalidStreamId.
5886 assert_eq!(
5887 client.cancel_push(PushId::new(0)),
5888 Err(Error::InvalidStreamId)
5889 );
5890
5891 assert_eq!(client.state(), Http3State::Connected);
5892 }
5893
5894 // Test that a PUSH_PROMISE will be ignored after a push stream reset.
5895 #[test]
5896 fn cancel_push_stream_before_push_promise() {
5897 // Connect and send a request
5898 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5899
5900 // Start a push stream with push_id 0.
5901 let push_stream_id =
5902 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
5903
5904 server
5905 .conn
5906 .stream_reset_send(push_stream_id, Error::HttpRequestCancelled.code())
5907 .unwrap();
5908 let out = server.conn.process_output(now());
5909 client.process(out.dgram(), now());
5910
5911 send_push_promise_and_exchange_packets(
5912 &mut client,
5913 &mut server,
5914 request_stream_id,
5915 PushId::new(0),
5916 );
5917
5918 // Assert that we do not have any push event.
5919 assert!(!check_push_events(&mut client));
5920
5921 // Check that the push has been closed, e.g. calling cancel_push should return
5922 // InvalidStreamId.
5923 assert_eq!(
5924 client.cancel_push(PushId::new(0)),
5925 Err(Error::InvalidStreamId)
5926 );
5927
5928 assert_eq!(client.state(), Http3State::Connected);
5929 }
5930
5931 // Test that push_promise events will be removed after application calls cancel_push.
5932 #[test]
5933 fn app_cancel_push_after_push_promise() {
5934 // Connect and send a request
5935 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5936
5937 send_push_promise_and_exchange_packets(
5938 &mut client,
5939 &mut server,
5940 request_stream_id,
5941 PushId::new(0),
5942 );
5943
5944 assert!(client.cancel_push(PushId::new(0)).is_ok());
5945
5946 // Assert that we do not have any push event.
5947 assert!(!check_push_events(&mut client));
5948
5949 // Check that the push has been closed, e.g. calling cancel_push should return
5950 // InvalidStreamId.
5951 assert_eq!(
5952 client.cancel_push(PushId::new(0)),
5953 Err(Error::InvalidStreamId)
5954 );
5955
5956 assert_eq!(client.state(), Http3State::Connected);
5957 }
5958
5959 // Test that push_promise and push data events will be removed after application calls
5960 // cancel_push.
5961 #[test]
5962 fn app_cancel_push_after_push_promise_and_push_stream() {
5963 // Connect and send a request
5964 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
5965
5966 send_push_promise_and_exchange_packets(
5967 &mut client,
5968 &mut server,
5969 request_stream_id,
5970 PushId::new(0),
5971 );
5972 let push_stream_id =
5973 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
5974
5975 assert!(client.cancel_push(PushId::new(0)).is_ok());
5976 let out = client.process_output(now());
5977 drop(server.conn.process(out.dgram(), now()));
5978
5979 // Assert that we do not have any push event.
5980 assert!(!check_push_events(&mut client));
5981
5982 // Check that the push has been closed, e.g. calling cancel_push should return
5983 // InvalidStreamId.
5984 assert_eq!(
5985 client.cancel_push(PushId::new(0)),
5986 Err(Error::InvalidStreamId)
5987 );
5988
5989 // Check that the push has been canceled by the client.
5990 assert_stop_sending_event(
5991 &mut server,
5992 push_stream_id,
5993 Error::HttpRequestCancelled.code(),
5994 );
5995
5996 assert_eq!(client.state(), Http3State::Connected);
5997 }
5998
5999 // Test that push_promise events will be ignored after application calls cancel_push.
6000 #[test]
6001 fn app_cancel_push_before_push_promise() {
6002 // Connect and send a request
6003 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6004
6005 send_push_promise_and_exchange_packets(
6006 &mut client,
6007 &mut server,
6008 request_stream_id,
6009 PushId::new(0),
6010 );
6011 let push_stream_id =
6012 send_push_data_and_exchange_packets(&mut client, &mut server, PushId::new(0), false);
6013
6014 assert!(client.cancel_push(PushId::new(0)).is_ok());
6015 let out = client.process_output(now());
6016 drop(server.conn.process(out.dgram(), now()));
6017
6018 send_push_promise_and_exchange_packets(
6019 &mut client,
6020 &mut server,
6021 request_stream_id,
6022 PushId::new(0),
6023 );
6024
6025 // Assert that we do not have any push event.
6026 assert!(!check_push_events(&mut client));
6027
6028 // Check that the push has been closed, e.g. calling cancel_push should return
6029 // InvalidStreamId.
6030 assert_eq!(
6031 client.cancel_push(PushId::new(0)),
6032 Err(Error::InvalidStreamId)
6033 );
6034
6035 // Check that the push has been canceled by the client.
6036 assert_stop_sending_event(
6037 &mut server,
6038 push_stream_id,
6039 Error::HttpRequestCancelled.code(),
6040 );
6041
6042 assert_eq!(client.state(), Http3State::Connected);
6043 }
6044
6045 fn setup_server_side_encoder_param(
6046 client: &mut Http3Client,
6047 server: &mut TestServer,
6048 max_blocked_streams: u64,
6049 ) {
6050 server
6051 .encoder
6052 .borrow_mut()
6053 .set_max_capacity(max_blocked_streams)
6054 .unwrap();
6055 server
6056 .encoder
6057 .borrow_mut()
6058 .set_max_blocked_streams(100)
6059 .unwrap();
6060 server
6061 .encoder
6062 .borrow_mut()
6063 .send_encoder_updates(&mut server.conn)
6064 .unwrap();
6065 let out = server.conn.process_output(now());
6066 drop(client.process(out.dgram(), now()));
6067 }
6068
6069 fn setup_server_side_encoder(client: &mut Http3Client, server: &mut TestServer) {
6070 setup_server_side_encoder_param(client, server, 100);
6071 }
6072
6073 fn send_push_promise_using_encoder(
6074 client: &mut Http3Client,
6075 server: &mut TestServer,
6076 stream_id: StreamId,
6077 push_id: PushId,
6078 ) -> Option<Datagram> {
6079 send_push_promise_using_encoder_with_custom_headers(
6080 client,
6081 server,
6082 stream_id,
6083 push_id,
6084 Header::new("my-header", "my-value"),
6085 )
6086 }
6087
6088 fn send_push_promise_using_encoder_with_custom_headers(
6089 client: &mut Http3Client,
6090 server: &mut TestServer,
6091 stream_id: StreamId,
6092 push_id: PushId,
6093 additional_header: Header,
6094 ) -> Option<Datagram> {
6095 let mut headers = vec![
6096 Header::new(":method", "GET"),
6097 Header::new(":scheme", "https"),
6098 Header::new(":authority", "something.com"),
6099 Header::new(":path", "/"),
6100 Header::new("content-length", "3"),
6101 ];
6102 headers.push(additional_header);
6103
6104 let encoded_headers =
6105 server
6106 .encoder
6107 .borrow_mut()
6108 .encode_header_block(&mut server.conn, &headers, stream_id);
6109 let push_promise_frame = HFrame::PushPromise {
6110 push_id,
6111 header_block: encoded_headers.to_vec(),
6112 };
6113
6114 // Send the encoder instructions, but delay them so that the stream is blocked on decoding
6115 // headers.
6116 let encoder_inst_pkt = server.conn.process_output(now()).dgram();
6117 assert!(encoder_inst_pkt.is_some());
6118
6119 let mut d = Encoder::default();
6120 push_promise_frame.encode(&mut d);
6121 server_send_response_and_exchange_packet(client, server, stream_id, &d, false);
6122
6123 encoder_inst_pkt
6124 }
6125
6126 #[test]
6127 fn push_promise_header_decoder_block() {
6128 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6129
6130 setup_server_side_encoder(&mut client, &mut server);
6131
6132 let encoder_inst_pkt = send_push_promise_using_encoder(
6133 &mut client,
6134 &mut server,
6135 request_stream_id,
6136 PushId::new(0),
6137 );
6138
6139 // PushPromise is blocked watching for encoder instructions.
6140 assert!(!check_push_events(&mut client));
6141
6142 // Let client receive the encoder instructions.
6143 let _out = client.process(encoder_inst_pkt, now());
6144
6145 // PushPromise is blocked watching for encoder instructions.
6146 assert!(check_push_events(&mut client));
6147 }
6148
6149 // If PushPromise is blocked, stream data can still be received.
6150 #[test]
6151 fn push_promise_blocked_but_stream_is_not_blocked() {
6152 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6153
6154 setup_server_side_encoder(&mut client, &mut server);
6155
6156 // Send response headers
6157 server_send_response_and_exchange_packet(
6158 &mut client,
6159 &mut server,
6160 request_stream_id,
6161 HTTP_RESPONSE_HEADER_ONLY_1,
6162 false,
6163 );
6164
6165 let encoder_inst_pkt = send_push_promise_using_encoder(
6166 &mut client,
6167 &mut server,
6168 request_stream_id,
6169 PushId::new(0),
6170 );
6171
6172 // PushPromise is blocked watching for encoder instructions.
6173 assert!(!check_push_events(&mut client));
6174
6175 // Stream data can be still read
6176 server_send_response_and_exchange_packet(
6177 &mut client,
6178 &mut server,
6179 request_stream_id,
6180 HTTP_RESPONSE_DATA_FRAME_1_ONLY_1,
6181 false,
6182 );
6183
6184 assert!(check_data_readable(&mut client));
6185
6186 // Let client receive the encoder instructions.
6187 let _out = client.process(encoder_inst_pkt, now());
6188
6189 // PushPromise is blocked watching for encoder instructions.
6190 assert!(check_push_events(&mut client));
6191
6192 // Stream data can be still read
6193 server_send_response_and_exchange_packet(
6194 &mut client,
6195 &mut server,
6196 request_stream_id,
6197 HTTP_RESPONSE_DATA_FRAME_2_ONLY_1,
6198 false,
6199 );
6200
6201 assert!(check_data_readable(&mut client));
6202 }
6203
6204 // The response Headers are not block if they do not refer the dynamic table.
6205 #[test]
6206 fn push_promise_does_not_block_headers() {
6207 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6208
6209 setup_server_side_encoder(&mut client, &mut server);
6210
6211 let encoder_inst_pkt = send_push_promise_using_encoder(
6212 &mut client,
6213 &mut server,
6214 request_stream_id,
6215 PushId::new(0),
6216 );
6217
6218 // PushPromise is blocked watching for encoder instructions.
6219 assert!(!check_push_events(&mut client));
6220
6221 // Send response headers
6222 server_send_response_and_exchange_packet(
6223 &mut client,
6224 &mut server,
6225 request_stream_id,
6226 HTTP_RESPONSE_HEADER_ONLY_1,
6227 false,
6228 );
6229
6230 assert!(check_header_ready(&mut client));
6231
6232 // Let client receive the encoder instructions.
6233 let _out = client.process(encoder_inst_pkt, now());
6234
6235 // PushPromise is blocked watching for encoder instructions.
6236 assert!(check_push_events(&mut client));
6237 }
6238
6239 // The response Headers are blocked if they refer a dynamic table entry.
6240 #[test]
6241 fn push_promise_block_headers() {
6242 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6243
6244 setup_server_side_encoder(&mut client, &mut server);
6245
6246 // Insert an element into a dynamic table.
6247 // insert "content-length: 1234
6248 server
6249 .encoder
6250 .borrow_mut()
6251 .send_and_insert(&mut server.conn, b"content-length", b"1234")
6252 .unwrap();
6253 let encoder_inst_pkt1 = server.conn.process_output(now()).dgram();
6254 let _out = client.process(encoder_inst_pkt1, now());
6255
6256 // Send a PushPromise that is blocked until encoder_inst_pkt2 is process by the client.
6257 let encoder_inst_pkt2 = send_push_promise_using_encoder(
6258 &mut client,
6259 &mut server,
6260 request_stream_id,
6261 PushId::new(0),
6262 );
6263
6264 // PushPromise is blocked watching for encoder instructions.
6265 assert!(!check_push_events(&mut client));
6266
6267 let response_headers = vec![
6268 Header::new(":status", "200"),
6269 Header::new("content-length", "1234"),
6270 ];
6271 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
6272 &mut server.conn,
6273 &response_headers,
6274 request_stream_id,
6275 );
6276 let header_hframe = HFrame::Headers {
6277 header_block: encoded_headers.to_vec(),
6278 };
6279 let mut d = Encoder::default();
6280 header_hframe.encode(&mut d);
6281 server_send_response_and_exchange_packet(
6282 &mut client,
6283 &mut server,
6284 request_stream_id,
6285 &d,
6286 false,
6287 );
6288
6289 // The response headers are blocked.
6290 assert!(!check_header_ready(&mut client));
6291
6292 // Let client receive the encoder instructions.
6293 let _out = client.process(encoder_inst_pkt2, now());
6294
6295 // The response headers are blocked.
6296 assert!(check_header_ready_and_push_promise(&mut client));
6297 }
6298
6299 // In this test there are 2 push promises that are blocked and the response header is
6300 // blocked as well. After a packet is received only the first push promises is unblocked.
6301 #[test]
6302 fn two_push_promises_and_header_block() {
6303 let mut client = default_http3_client_param(200);
6304 let mut server = TestServer::new_with_settings(&[
6305 HSetting::new(HSettingType::MaxTableCapacity, 200),
6306 HSetting::new(HSettingType::BlockedStreams, 100),
6307 HSetting::new(HSettingType::MaxHeaderListSize, 10000),
6308 ]);
6309 connect_only_transport_with(&mut client, &mut server);
6310 server.create_control_stream();
6311 server.create_qpack_streams();
6312 setup_server_side_encoder_param(&mut client, &mut server, 200);
6313
6314 let request_stream_id = make_request_and_exchange_pkts(&mut client, &mut server, true);
6315
6316 // Send a PushPromise that is blocked until encoder_inst_pkt2 is process by the client.
6317 let encoder_inst_pkt1 = send_push_promise_using_encoder_with_custom_headers(
6318 &mut client,
6319 &mut server,
6320 request_stream_id,
6321 PushId::new(0),
6322 Header::new("myn1", "myv1"),
6323 );
6324
6325 // PushPromise is blocked watching for encoder instructions.
6326 assert!(!check_push_events(&mut client));
6327
6328 let encoder_inst_pkt2 = send_push_promise_using_encoder_with_custom_headers(
6329 &mut client,
6330 &mut server,
6331 request_stream_id,
6332 PushId::new(1),
6333 Header::new("myn2", "myv2"),
6334 );
6335
6336 // PushPromise is blocked watching for encoder instructions.
6337 assert!(!check_push_events(&mut client));
6338
6339 let response_headers = vec![
6340 Header::new(":status", "200"),
6341 Header::new("content-length", "1234"),
6342 Header::new("myn3", "myv3"),
6343 ];
6344 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
6345 &mut server.conn,
6346 &response_headers,
6347 request_stream_id,
6348 );
6349 let header_hframe = HFrame::Headers {
6350 header_block: encoded_headers.to_vec(),
6351 };
6352 let mut d = Encoder::default();
6353 header_hframe.encode(&mut d);
6354 server_send_response_and_exchange_packet(
6355 &mut client,
6356 &mut server,
6357 request_stream_id,
6358 &d,
6359 false,
6360 );
6361
6362 // The response headers are blocked.
6363 assert!(!check_header_ready(&mut client));
6364
6365 // Let client receive the encoder instructions.
6366 let _out = client.process(encoder_inst_pkt1, now());
6367
6368 assert!(check_push_events(&mut client));
6369
6370 // Let client receive the encoder instructions.
6371 let _out = client.process(encoder_inst_pkt2, now());
6372
6373 assert!(check_header_ready_and_push_promise(&mut client));
6374 }
6375
6376 // The PushPromise blocked on header decoding will be canceled if the stream is closed.
6377 #[test]
6378 fn blocked_push_promises_canceled() {
6379 const STREAM_CANCELED_ID_0: &[u8] = &[0x40];
6380
6381 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6382
6383 setup_server_side_encoder(&mut client, &mut server);
6384
6385 drop(
6386 send_push_promise_using_encoder(
6387 &mut client,
6388 &mut server,
6389 request_stream_id,
6390 PushId::new(0),
6391 )
6392 .unwrap(),
6393 );
6394
6395 server_send_response_and_exchange_packet(
6396 &mut client,
6397 &mut server,
6398 request_stream_id,
6399 HTTP_RESPONSE_1,
6400 true,
6401 );
6402
6403 // Read response that will make stream change to closed state.
6404 assert!(check_header_ready(&mut client));
6405 let mut buf = [0_u8; 100];
6406 _ = client
6407 .read_data(now(), request_stream_id, &mut buf)
6408 .unwrap();
6409
6410 let out = client.process_output(now());
6411 drop(server.conn.process(out.dgram(), now()));
6412 // Check that encoder got stream_canceled instruction.
6413 let mut inst = [0_u8; 100];
6414 let (amount, fin) = server
6415 .conn
6416 .stream_recv(CLIENT_SIDE_DECODER_STREAM_ID, &mut inst)
6417 .unwrap();
6418 assert!(!fin);
6419 assert_eq!(amount, STREAM_CANCELED_ID_0.len());
6420 assert_eq!(&inst[..amount], STREAM_CANCELED_ID_0);
6421 }
6422
6423 #[test]
6424 fn data_readable_in_decoder_blocked_state() {
6425 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6426
6427 setup_server_side_encoder(&mut client, &mut server);
6428
6429 let headers = vec![
6430 Header::new(":status", "200"),
6431 Header::new("my-header", "my-header"),
6432 Header::new("content-length", "0"),
6433 ];
6434 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
6435 &mut server.conn,
6436 &headers,
6437 request_stream_id,
6438 );
6439 let hframe = HFrame::Headers {
6440 header_block: encoded_headers.to_vec(),
6441 };
6442
6443 // Delay encoder instruction so that the stream will be blocked.
6444 let encoder_insts = server.conn.process_output(now());
6445
6446 // Send response headers.
6447 let mut d = Encoder::default();
6448 hframe.encode(&mut d);
6449 server_send_response_and_exchange_packet(
6450 &mut client,
6451 &mut server,
6452 request_stream_id,
6453 &d,
6454 false,
6455 );
6456
6457 // Headers are blocked waiting for the encoder instructions.
6458 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
6459 assert!(!client.events().any(header_ready_event));
6460
6461 // Now send data frame. This will trigger DataRead event.
6462 let mut d = Encoder::default();
6463 hframe.encode(&mut d);
6464 let d_frame = HFrame::Data { len: 0 };
6465 d_frame.encode(&mut d);
6466 server_send_response_and_exchange_packet(
6467 &mut client,
6468 &mut server,
6469 request_stream_id,
6470 &d,
6471 true,
6472 );
6473
6474 // Now read headers.
6475 drop(client.process(encoder_insts.dgram(), now()));
6476 }
6477
6478 #[test]
6479 fn qpack_stream_reset() {
6480 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6481 setup_server_side_encoder(&mut client, &mut server);
6482 // Cancel request.
6483 drop(client.cancel_fetch(request_stream_id, Error::HttpRequestCancelled.code()));
6484 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6485 let out = client.process_output(now());
6486 drop(server.conn.process(out.dgram(), now()));
6487 drop(server.encoder_receiver.receive(&mut server.conn));
6488 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 1);
6489 }
6490
6491 fn send_headers_using_encoder(
6492 client: &mut Http3Client,
6493 server: &mut TestServer,
6494 request_stream_id: StreamId,
6495 headers: &[Header],
6496 data: &[u8],
6497 ) -> Option<Datagram> {
6498 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
6499 &mut server.conn,
6500 headers,
6501 request_stream_id,
6502 );
6503 let hframe = HFrame::Headers {
6504 header_block: encoded_headers.to_vec(),
6505 };
6506
6507 let out = server.conn.process_output(now());
6508
6509 // Send response
6510 let mut d = Encoder::default();
6511 hframe.encode(&mut d);
6512 let d_frame = HFrame::Data {
6513 len: u64::try_from(data.len()).unwrap(),
6514 };
6515 d_frame.encode(&mut d);
6516 d.encode(data);
6517 server_send_response_and_exchange_packet(client, server, request_stream_id, &d, true);
6518
6519 out.dgram()
6520 }
6521
6522 #[test]
6523 fn qpack_stream_reset_recv() {
6524 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6525 setup_server_side_encoder(&mut client, &mut server);
6526
6527 // Cancel request.
6528 server
6529 .conn
6530 .stream_reset_send(request_stream_id, Error::HttpRequestCancelled.code())
6531 .unwrap();
6532 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6533 let out = server.conn.process_output(now());
6534 let out = client.process(out.dgram(), now());
6535 drop(server.conn.process(out.dgram(), now()));
6536 drop(server.encoder_receiver.receive(&mut server.conn));
6537 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 1);
6538 }
6539
6540 #[test]
6541 fn qpack_stream_reset_during_header_qpack_blocked() {
6542 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6543
6544 setup_server_side_encoder(&mut client, &mut server);
6545
6546 drop(
6547 send_headers_using_encoder(
6548 &mut client,
6549 &mut server,
6550 request_stream_id,
6551 &[
6552 Header::new(":status", "200"),
6553 Header::new("my-header", "my-header"),
6554 Header::new("content-length", "3"),
6555 ],
6556 &[0x61, 0x62, 0x63],
6557 )
6558 .unwrap(),
6559 );
6560
6561 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
6562 assert!(!client.events().any(header_ready_event));
6563
6564 // Cancel request.
6565 client
6566 .cancel_fetch(request_stream_id, Error::HttpRequestCancelled.code())
6567 .unwrap();
6568
6569 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6570 let out = client.process_output(now());
6571 drop(server.conn.process(out.dgram(), now()));
6572 drop(server.encoder_receiver.receive(&mut server.conn).unwrap());
6573 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 1);
6574 }
6575
6576 #[test]
6577 fn qpack_no_stream_cancelled_after_fin() {
6578 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6579
6580 setup_server_side_encoder(&mut client, &mut server);
6581
6582 let encoder_instruct = send_headers_using_encoder(
6583 &mut client,
6584 &mut server,
6585 request_stream_id,
6586 &[
6587 Header::new(":status", "200"),
6588 Header::new("my-header", "my-header"),
6589 Header::new("content-length", "3"),
6590 ],
6591 &[],
6592 );
6593
6594 // Exchange encoder instructions
6595 drop(client.process(encoder_instruct, now()));
6596
6597 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
6598 assert!(client.events().any(header_ready_event));
6599 // After this the recv_stream is in ClosePending state
6600
6601 // Cancel request.
6602 client
6603 .cancel_fetch(request_stream_id, Error::HttpRequestCancelled.code())
6604 .unwrap();
6605
6606 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6607 let out = client.process_output(now());
6608 drop(server.conn.process(out.dgram(), now()));
6609 drop(server.encoder_receiver.receive(&mut server.conn).unwrap());
6610 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6611 }
6612
6613 #[test]
6614 fn qpack_stream_reset_push_promise_header_decoder_block() {
6615 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6616
6617 setup_server_side_encoder(&mut client, &mut server);
6618
6619 let headers = vec![
6620 Header::new(":status", "200"),
6621 Header::new("content-length", "3"),
6622 ];
6623 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
6624 &mut server.conn,
6625 &headers,
6626 request_stream_id,
6627 );
6628 let hframe = HFrame::Headers {
6629 header_block: encoded_headers.to_vec(),
6630 };
6631
6632 // Send the encoder instructions.
6633 let out = server.conn.process_output(now());
6634 drop(client.process(out.dgram(), now()));
6635
6636 // Send PushPromise that will be blocked waiting for decoder instructions.
6637 drop(
6638 send_push_promise_using_encoder(
6639 &mut client,
6640 &mut server,
6641 request_stream_id,
6642 PushId::new(0),
6643 )
6644 .unwrap(),
6645 );
6646
6647 // Send response
6648 let mut d = Encoder::default();
6649 hframe.encode(&mut d);
6650 let d_frame = HFrame::Data { len: 0 };
6651 d_frame.encode(&mut d);
6652 server_send_response_and_exchange_packet(
6653 &mut client,
6654 &mut server,
6655 request_stream_id,
6656 &d,
6657 true,
6658 );
6659
6660 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
6661 assert!(client.events().any(header_ready_event));
6662
6663 // Cancel request.
6664 client
6665 .cancel_fetch(request_stream_id, Error::HttpRequestCancelled.code())
6666 .unwrap();
6667
6668 let out = client.process_output(now());
6669 drop(server.conn.process(out.dgram(), now()));
6670 drop(server.encoder_receiver.receive(&mut server.conn).unwrap());
6671 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 1);
6672 }
6673
6674 #[test]
6675 fn qpack_stream_reset_dynamic_table_zero() {
6676 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6677 // Cancel request.
6678 client
6679 .cancel_fetch(request_stream_id, Error::HttpRequestCancelled.code())
6680 .unwrap();
6681 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6682 let out = client.process_output(now());
6683 drop(server.conn.process(out.dgram(), now()));
6684 drop(server.encoder_receiver.receive(&mut server.conn).unwrap());
6685 assert_eq!(server.encoder.borrow_mut().stats().stream_cancelled_recv, 0);
6686 }
6687
6688 #[test]
6689 fn multiple_streams_in_decoder_blocked_state() {
6690 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6691
6692 setup_server_side_encoder(&mut client, &mut server);
6693
6694 let headers = vec![
6695 Header::new(":status", "200"),
6696 Header::new("my-header", "my-header"),
6697 Header::new("content-length", "0"),
6698 ];
6699 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
6700 &mut server.conn,
6701 &headers,
6702 request_stream_id,
6703 );
6704 let hframe = HFrame::Headers {
6705 header_block: encoded_headers.to_vec(),
6706 };
6707
6708 // Delay encoder instruction so that the stream will be blocked.
6709 let encoder_insts = server.conn.process_output(now());
6710
6711 // Send response headers.
6712 let mut d = Encoder::default();
6713 hframe.encode(&mut d);
6714 server_send_response_and_exchange_packet(
6715 &mut client,
6716 &mut server,
6717 request_stream_id,
6718 &d,
6719 true,
6720 );
6721
6722 // Headers are blocked waiting for the encoder instructions.
6723 let header_ready_event = |e| matches!(e, Http3ClientEvent::HeaderReady { .. });
6724 assert!(!client.events().any(header_ready_event));
6725
6726 // Make another request.
6727 let request2 = make_request_and_exchange_pkts(&mut client, &mut server, true);
6728 // Send response headers.
6729 server_send_response_and_exchange_packet(&mut client, &mut server, request2, &d, true);
6730
6731 // Headers on the second request are blocked as well are blocked
6732 // waiting for the encoder instructions.
6733 assert!(!client.events().any(header_ready_event));
6734
6735 // Now make the encoder instructions available.
6736 drop(client.process(encoder_insts.dgram(), now()));
6737
6738 // Header blocks for both streams should be ready.
6739 let mut count_responses = 0;
6740 while let Some(e) = client.next_event() {
6741 if let Http3ClientEvent::HeaderReady { stream_id, .. } = e {
6742 assert!((stream_id == request_stream_id) || (stream_id == request2));
6743 count_responses += 1;
6744 }
6745 }
6746 assert_eq!(count_responses, 2);
6747 }
6748
6749 #[test]
6750 fn reserved_frames() {
6751 for f in H3_RESERVED_FRAME_TYPES {
6752 let mut enc = Encoder::default();
6753 enc.encode_varint(*f);
6754 test_wrong_frame_on_control_stream(enc.as_ref());
6755 test_wrong_frame_on_push_stream(enc.as_ref());
6756 test_wrong_frame_on_request_stream(enc.as_ref());
6757 }
6758 }
6759
6760 #[test]
6761 fn send_reserved_settings() {
6762 for s in H3_RESERVED_SETTINGS {
6763 let (mut client, mut server) = connect_only_transport();
6764 let control_stream = server.conn.stream_create(StreamType::UniDi).unwrap();
6765 // Send the control stream type(0x0).
6766 _ = server
6767 .conn
6768 .stream_send(control_stream, CONTROL_STREAM_TYPE)
6769 .unwrap();
6770 // Create a settings frame of length 2.
6771 let mut enc = Encoder::default();
6772 enc.encode_varint(H3_FRAME_TYPE_SETTINGS);
6773 enc.encode_varint(2_u64);
6774 // The settings frame contains a reserved settings type and some value (0x1).
6775 enc.encode_varint(*s);
6776 enc.encode_varint(1_u64);
6777 let sent = server.conn.stream_send(control_stream, enc.as_ref());
6778 assert_eq!(sent, Ok(4));
6779 let out = server.conn.process_output(now());
6780 client.process(out.dgram(), now());
6781 assert_closed(&client, &Error::HttpSettings);
6782 }
6783 }
6784
6785 #[test]
6786 fn response_w_1xx() {
6787 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6788
6789 setup_server_side_encoder(&mut client, &mut server);
6790
6791 let mut d = Encoder::default();
6792 let headers1xx: &[Header] = &[Header::new(":status", "103")];
6793 server.encode_headers(request_stream_id, headers1xx, &mut d);
6794
6795 let headers200: &[Header] = &[
6796 Header::new(":status", "200"),
6797 Header::new("my-header", "my-header"),
6798 Header::new("content-length", "3"),
6799 ];
6800 server.encode_headers(request_stream_id, headers200, &mut d);
6801
6802 // Send 1xx and 200 headers response.
6803 server_send_response_and_exchange_packet(
6804 &mut client,
6805 &mut server,
6806 request_stream_id,
6807 &d,
6808 false,
6809 );
6810
6811 // Sending response data.
6812 server_send_response_and_exchange_packet(
6813 &mut client,
6814 &mut server,
6815 request_stream_id,
6816 HTTP_RESPONSE_DATA_FRAME_ONLY_2,
6817 true,
6818 );
6819
6820 let mut events = client.events().filter_map(|e| {
6821 if let Http3ClientEvent::HeaderReady {
6822 stream_id,
6823 interim,
6824 headers,
6825 ..
6826 } = e
6827 {
6828 Some((stream_id, interim, headers))
6829 } else {
6830 None
6831 }
6832 });
6833 let (stream_id_1xx_rec, interim1xx_rec, headers1xx_rec) = events.next().unwrap();
6834 assert_eq!(
6835 (stream_id_1xx_rec, interim1xx_rec, headers1xx_rec.as_ref()),
6836 (request_stream_id, true, headers1xx)
6837 );
6838
6839 let (stream_id_200_rec, interim200_rec, headers200_rec) = events.next().unwrap();
6840 assert_eq!(
6841 (stream_id_200_rec, interim200_rec, headers200_rec.as_ref()),
6842 (request_stream_id, false, headers200)
6843 );
6844 assert!(events.next().is_none());
6845 }
6846
6847 #[test]
6848 fn response_wo_status() {
6849 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6850
6851 setup_server_side_encoder(&mut client, &mut server);
6852
6853 let mut d = Encoder::default();
6854 let headers = vec![
6855 Header::new("my-header", "my-header"),
6856 Header::new("content-length", "3"),
6857 ];
6858 server.encode_headers(request_stream_id, &headers, &mut d);
6859
6860 // Send response
6861 server_send_response_and_exchange_packet(
6862 &mut client,
6863 &mut server,
6864 request_stream_id,
6865 &d,
6866 false,
6867 );
6868
6869 // Stream has been reset because of the malformed headers.
6870 let e = client.events().next().unwrap();
6871 assert_eq!(
6872 e,
6873 Http3ClientEvent::Reset {
6874 stream_id: request_stream_id,
6875 error: Error::InvalidHeader.code(),
6876 local: true,
6877 }
6878 );
6879
6880 let out = client.process_output(now());
6881 drop(server.conn.process(out.dgram(), now()));
6882
6883 // Check that server has received a reset.
6884 let stop_sending_event = |e| {
6885 matches!(e, ConnectionEvent::SendStreamStopSending {
6886 stream_id,
6887 app_error
6888 } if stream_id == request_stream_id && app_error == Error::InvalidHeader.code())
6889 };
6890 assert!(server.conn.events().any(stop_sending_event));
6891
6892 // Stream should now be closed and gone
6893 let mut buf = [0_u8; 100];
6894 assert_eq!(
6895 client.read_data(now(), StreamId::new(0), &mut buf),
6896 Err(Error::InvalidStreamId)
6897 );
6898 }
6899
6900 // Client: receive a push stream
6901 #[test]
6902 fn push_single_with_1xx() {
6903 const FIRST_PUSH_ID: PushId = PushId::new(0);
6904 // Connect and send a request
6905 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6906
6907 // Send a push promise.
6908 send_push_promise(&mut server.conn, request_stream_id, FIRST_PUSH_ID);
6909 // Create a push stream
6910 let push_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap();
6911
6912 let mut d = Encoder::default();
6913 let headers1xx: &[Header] = &[Header::new(":status", "100")];
6914 server.encode_headers(push_stream_id, headers1xx, &mut d);
6915
6916 let headers200: &[Header] = &[
6917 Header::new(":status", "200"),
6918 Header::new("my-header", "my-header"),
6919 Header::new("content-length", "3"),
6920 ];
6921 server.encode_headers(push_stream_id, headers200, &mut d);
6922
6923 // create a push stream.
6924 send_data_on_push(&mut server.conn, push_stream_id, FIRST_PUSH_ID, &d, true);
6925
6926 server_send_response_and_exchange_packet(
6927 &mut client,
6928 &mut server,
6929 request_stream_id,
6930 HTTP_RESPONSE_2,
6931 true,
6932 );
6933
6934 let mut events = client.events().filter_map(|e| {
6935 if let Http3ClientEvent::PushHeaderReady {
6936 push_id,
6937 interim,
6938 headers,
6939 ..
6940 } = e
6941 {
6942 Some((push_id, interim, headers))
6943 } else {
6944 None
6945 }
6946 });
6947
6948 let (push_id_1xx_rec, interim1xx_rec, headers1xx_rec) = events.next().unwrap();
6949 assert_eq!(
6950 (push_id_1xx_rec, interim1xx_rec, headers1xx_rec.as_ref()),
6951 (FIRST_PUSH_ID, true, headers1xx)
6952 );
6953
6954 let (push_id_200_rec, interim200_rec, headers200_rec) = events.next().unwrap();
6955 assert_eq!(
6956 (push_id_200_rec, interim200_rec, headers200_rec.as_ref()),
6957 (FIRST_PUSH_ID, false, headers200)
6958 );
6959 assert!(events.next().is_none());
6960 }
6961
6962 // Client: receive a push stream
6963 #[test]
6964 fn push_single_wo_status() {
6965 const FIRST_PUSH_ID: PushId = PushId::new(0);
6966 // Connect and send a request
6967 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
6968
6969 // Send a push promise.
6970 send_push_promise(&mut server.conn, request_stream_id, FIRST_PUSH_ID);
6971 // Create a push stream
6972 let push_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap();
6973
6974 let mut d = Encoder::default();
6975 let headers = vec![
6976 Header::new("my-header", "my-header"),
6977 Header::new("content-length", "3"),
6978 ];
6979 server.encode_headers(request_stream_id, &headers, &mut d);
6980
6981 send_data_on_push(&mut server.conn, push_stream_id, FIRST_PUSH_ID, &d, false);
6982
6983 server_send_response_and_exchange_packet(
6984 &mut client,
6985 &mut server,
6986 request_stream_id,
6987 HTTP_RESPONSE_2,
6988 true,
6989 );
6990
6991 // Stream has been reset because of their malformed headers.
6992 let push_reset_event = |e| {
6993 matches!(e, Http3ClientEvent::PushReset {
6994 push_id,
6995 error,
6996 } if push_id == FIRST_PUSH_ID && error == Error::InvalidHeader.code())
6997 };
6998
6999 assert!(client.events().any(push_reset_event));
7000
7001 let out = client.process_output(now());
7002 drop(server.conn.process(out.dgram(), now()));
7003
7004 // Check that server has received a reset.
7005 let stop_sending_event = |e| {
7006 matches!(e, ConnectionEvent::SendStreamStopSending {
7007 stream_id,
7008 app_error
7009 } if stream_id == push_stream_id && app_error == Error::InvalidHeader.code())
7010 };
7011 assert!(server.conn.events().any(stop_sending_event));
7012 }
7013
7014 fn handshake_client_error(client: &mut Http3Client, server: &mut TestServer, error: &Error) {
7015 let out = handshake_only(client, server);
7016 client.process(out.dgram(), now());
7017 assert_closed(client, error);
7018 }
7019
7020 /// Client fails to create a control stream, since server does not allow it.
7021 #[test]
7022 fn client_control_stream_create_failed() {
7023 let mut client = default_http3_client();
7024 let mut server = TestServer::new_with_conn(new_server(
7025 DEFAULT_ALPN_H3,
7026 ConnectionParameters::default().max_streams(StreamType::UniDi, 0),
7027 ));
7028 handshake_client_error(&mut client, &mut server, &Error::StreamLimitError);
7029 }
7030
7031 /// 2 streams isn't enough for control and QPACK streams.
7032 #[test]
7033 fn client_qpack_stream_create_failed() {
7034 let mut client = default_http3_client();
7035 let mut server = TestServer::new_with_conn(new_server(
7036 DEFAULT_ALPN_H3,
7037 ConnectionParameters::default().max_streams(StreamType::UniDi, 2),
7038 ));
7039 handshake_client_error(&mut client, &mut server, &Error::StreamLimitError);
7040 }
7041
7042 fn do_malformed_response_test(headers: &[Header]) {
7043 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
7044
7045 setup_server_side_encoder(&mut client, &mut server);
7046
7047 let mut d = Encoder::default();
7048 server.encode_headers(request_stream_id, headers, &mut d);
7049
7050 // Send response
7051 server_send_response_and_exchange_packet(
7052 &mut client,
7053 &mut server,
7054 request_stream_id,
7055 &d,
7056 false,
7057 );
7058
7059 // Stream has been reset because of the malformed headers.
7060 let e = client.events().next().unwrap();
7061 assert_eq!(
7062 e,
7063 Http3ClientEvent::Reset {
7064 stream_id: request_stream_id,
7065 error: Error::InvalidHeader.code(),
7066 local: true,
7067 }
7068 );
7069 }
7070
7071 #[test]
7072 fn malformed_response_pseudo_header_after_regular_header() {
7073 do_malformed_response_test(&[
7074 Header::new("content-type", "text/plain"),
7075 Header::new(":status", "100"),
7076 ]);
7077 }
7078
7079 #[test]
7080 fn malformed_response_undefined_pseudo_header() {
7081 do_malformed_response_test(&[Header::new(":status", "200"), Header::new(":cheese", "200")]);
7082 }
7083
7084 #[test]
7085 fn malformed_response_duplicate_pseudo_header() {
7086 do_malformed_response_test(&[
7087 Header::new(":status", "200"),
7088 Header::new(":status", "100"),
7089 Header::new("content-type", "text/plain"),
7090 ]);
7091 }
7092
7093 #[test]
7094 fn malformed_response_uppercase_header() {
7095 do_malformed_response_test(&[
7096 Header::new(":status", "200"),
7097 Header::new("content-Type", "text/plain"),
7098 ]);
7099 }
7100
7101 #[test]
7102 fn malformed_response_excluded_header() {
7103 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
7104
7105 setup_server_side_encoder(&mut client, &mut server);
7106
7107 let mut d = Encoder::default();
7108 server.encode_headers(
7109 request_stream_id,
7110 &[
7111 Header::new(":status", "200"),
7112 Header::new("content-type", "text/plain"),
7113 Header::new("connection", "close"),
7114 ],
7115 &mut d,
7116 );
7117
7118 // Send response
7119 server_send_response_and_exchange_packet(
7120 &mut client,
7121 &mut server,
7122 request_stream_id,
7123 &d,
7124 false,
7125 );
7126
7127 // Stream has been reset because of the malformed headers.
7128 let e = client.events().next().unwrap();
7129 assert_eq!(
7130 e,
7131 Http3ClientEvent::HeaderReady {
7132 stream_id: request_stream_id,
7133 headers: vec![
7134 Header::new(":status", "200"),
7135 Header::new("content-type", "text/plain")
7136 ],
7137 interim: false,
7138 fin: false,
7139 }
7140 );
7141 }
7142
7143 #[test]
7144 fn malformed_response_excluded_byte_in_header() {
7145 do_malformed_response_test(&[
7146 Header::new(":status", "200"),
7147 Header::new("content:type", "text/plain"),
7148 ]);
7149 }
7150
7151 #[test]
7152 fn malformed_response_request_header_in_response() {
7153 do_malformed_response_test(&[
7154 Header::new(":status", "200"),
7155 Header::new(":method", "GET"),
7156 Header::new("content-type", "text/plain"),
7157 ]);
7158 }
7159
7160 fn maybe_authenticate(conn: &mut Http3Client) {
7161 let authentication_needed = |e| matches!(e, Http3ClientEvent::AuthenticationNeeded);
7162 if conn.events().any(authentication_needed) {
7163 conn.authenticated(AuthenticationStatus::Ok, now());
7164 }
7165 }
7166
7167 const MAX_TABLE_SIZE: u64 = 65536;
7168 const MAX_BLOCKED_STREAMS: u16 = 5;
7169
7170 fn get_resumption_token(server: &mut Http3Server) -> ResumptionToken {
7171 let mut client = default_http3_client_param(MAX_TABLE_SIZE);
7172
7173 let mut datagram = None;
7174 let is_done = |c: &Http3Client| matches!(c.state(), Http3State::Connected);
7175 while !is_done(&mut client) {
7176 maybe_authenticate(&mut client);
7177 datagram = client.process(datagram, now()).dgram();
7178 datagram = server.process(datagram, now()).dgram();
7179 }
7180
7181 // exchange qpack settings, server will send a token as well.
7182 datagram = client.process(datagram, now()).dgram();
7183 datagram = server.process(datagram, now()).dgram();
7184 drop(client.process(datagram, now()).dgram());
7185
7186 client
7187 .events()
7188 .find_map(|e| {
7189 if let Http3ClientEvent::ResumptionToken(token) = e {
7190 Some(token)
7191 } else {
7192 None
7193 }
7194 })
7195 .unwrap()
7196 }
7197
7198 // Test that decoder stream type is always sent before any other instruction also
7199 // in case when 0RTT is used.
7200 // A client will send a request that uses the dynamic table. This will trigger a header-ack
7201 // from a server. We will use stats to check that a header-ack has been received.
7202 #[test]
7203 fn zerortt_request_use_dynamic_table() {
7204 let mut server = Http3Server::new(
7205 now(),
7206 DEFAULT_KEYS,
7207 DEFAULT_ALPN_H3,
7208 anti_replay(),
7209 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
7210 Http3Parameters::default()
7211 .max_table_size_encoder(MAX_TABLE_SIZE)
7212 .max_table_size_decoder(MAX_TABLE_SIZE)
7213 .max_blocked_streams(MAX_BLOCKED_STREAMS),
7214 None,
7215 )
7216 .unwrap();
7217
7218 let token = get_resumption_token(&mut server);
7219 // Make a new connection.
7220 let mut client = default_http3_client_param(MAX_TABLE_SIZE);
7221 assert_eq!(client.state(), Http3State::Initializing);
7222 client
7223 .enable_resumption(now(), &token)
7224 .expect("Set resumption token");
7225
7226 assert_eq!(client.state(), Http3State::ZeroRtt);
7227 let zerortt_event = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::ZeroRtt));
7228 assert!(client.events().any(zerortt_event));
7229
7230 // Make a request that uses the dynamic table.
7231 _ = make_request(&mut client, true, &[Header::new("myheaders", "myvalue")]);
7232 // Assert that the request has used dynamic table. That will trigger a header_ack.
7233 assert_eq!(client.qpack_encoder_stats().dynamic_table_references, 1);
7234
7235 // Exchange packets until header-ack is received.
7236 // These many packet exchange is needed, to get a header-ack.
7237 // TODO this may be optimize at Http3Server.
7238 let out = client.process_output(now());
7239 let out = server.process(out.dgram(), now());
7240 let out = client.process(out.dgram(), now());
7241 let out = server.process(out.dgram(), now());
7242 let out = client.process(out.dgram(), now());
7243 let out = server.process(out.dgram(), now());
7244 let out = client.process(out.dgram(), now());
7245 let out = server.process(out.dgram(), now());
7246 drop(client.process(out.dgram(), now()));
7247
7248 // The header ack for the first request has been received.
7249 assert_eq!(client.qpack_encoder_stats().header_acks_recv, 1);
7250 }
7251
7252 fn manipulate_conrol_stream(client: &mut Http3Client, stream_id: StreamId) {
7253 assert_eq!(
7254 client
7255 .cancel_fetch(stream_id, Error::HttpNoError.code())
7256 .unwrap_err(),
7257 Error::InvalidStreamId
7258 );
7259 assert_eq!(
7260 client.stream_close_send(stream_id).unwrap_err(),
7261 Error::InvalidStreamId
7262 );
7263 let mut buf = [0; 2];
7264 assert_eq!(
7265 client.send_data(stream_id, &buf).unwrap_err(),
7266 Error::InvalidStreamId
7267 );
7268 assert_eq!(
7269 client.read_data(now(), stream_id, &mut buf).unwrap_err(),
7270 Error::InvalidStreamId
7271 );
7272 }
7273
7274 #[test]
7275 fn manipulate_conrol_streams() {
7276 let (mut client, server, request_stream_id) = connect_and_send_request(false);
7277 manipulate_conrol_stream(&mut client, CLIENT_SIDE_CONTROL_STREAM_ID);
7278 manipulate_conrol_stream(&mut client, CLIENT_SIDE_ENCODER_STREAM_ID);
7279 manipulate_conrol_stream(&mut client, CLIENT_SIDE_DECODER_STREAM_ID);
7280 manipulate_conrol_stream(&mut client, server.control_stream_id.unwrap());
7281 manipulate_conrol_stream(&mut client, server.encoder_stream_id.unwrap());
7282 manipulate_conrol_stream(&mut client, server.decoder_stream_id.unwrap());
7283 client
7284 .cancel_fetch(request_stream_id, Error::HttpNoError.code())
7285 .unwrap();
7286 }
7287
7288 // Client: receive a push stream
7289 #[test]
7290 fn incomple_push_stream() {
7291 let (mut client, mut server) = connect();
7292
7293 // Create a push stream
7294 let push_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap();
7295 _ = server
7296 .conn
7297 .stream_send(push_stream_id, PUSH_STREAM_TYPE)
7298 .unwrap();
7299 _ = server.conn.stream_send(push_stream_id, &[0]).unwrap();
7300 server.conn.stream_close_send(push_stream_id).unwrap();
7301 let out = server.conn.process_output(now());
7302 client.process(out.dgram(), now());
7303 assert_closed(&client, &Error::HttpGeneralProtocol);
7304 }
7305
7306 #[test]
7307 fn priority_update_during_full_buffer() {
7308 // set a lower MAX_DATA on the server side to restrict the data the client can send
7309 let (mut client, mut server) = connect_with_connection_parameters(
7310 ConnectionParameters::default().max_data(MIN_INITIAL_PACKET_SIZE.try_into().unwrap()),
7311 );
7312
7313 let request_stream_id = make_request_and_exchange_pkts(&mut client, &mut server, false);
7314 let data_writable = |e| matches!(e, Http3ClientEvent::DataWritable { .. });
7315 assert!(client.events().any(data_writable));
7316 // Send a lot of data to reach the flow control limit
7317 client.send_data(request_stream_id, &[0; 2000]).unwrap();
7318
7319 // now queue a priority_update packet for that stream
7320 assert!(client
7321 .priority_update(request_stream_id, Priority::new(6, false))
7322 .unwrap());
7323
7324 let md_before = server.conn.stats().frame_tx.max_data;
7325
7326 // sending the http request and most most of the request data
7327 let out = client.process_output(now());
7328 let out = server.conn.process(out.dgram(), now());
7329
7330 // the server responses with an ack, but the max_data didn't change
7331 assert_eq!(md_before, server.conn.stats().frame_tx.max_data);
7332
7333 let out = client.process(out.dgram(), now());
7334 let out = server.conn.process(out.dgram(), now());
7335
7336 // the server increased the max_data during the second read if that isn't the case
7337 // in the future and therefore this asserts fails, the request data on stream 0 could be
7338 // read to cause a max_update frame
7339 assert_eq!(md_before + 1, server.conn.stats().frame_tx.max_data);
7340
7341 // make sure that the server didn't receive a priority_update on client control stream
7342 // (stream_id 2) yet
7343 let mut buf = [0; 32];
7344 assert_eq!(
7345 server.conn.stream_recv(StreamId::new(2), &mut buf),
7346 Ok((0, false))
7347 );
7348
7349 // the client now sends the priority update
7350 let out = client.process(out.dgram(), now());
7351 server.conn.process_input(out.dgram().unwrap(), now());
7352
7353 // check that the priority_update arrived at the client control stream
7354 let num_read = server.conn.stream_recv(StreamId::new(2), &mut buf).unwrap();
7355 assert_eq!(b"\x80\x0f\x07\x00\x04\x00\x75\x3d\x36", &buf[0..num_read.0]);
7356 }
7357
7358 #[test]
7359 fn error_request_stream() {
7360 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
7361
7362 setup_server_side_encoder(&mut client, &mut server);
7363
7364 let headers = vec![
7365 Header::new(":status", "200"),
7366 Header::new(":method", "GET"), // <- invalid
7367 Header::new("my-header", "my-header"),
7368 Header::new("content-length", "3"),
7369 ];
7370 let encoded_headers = server.encoder.borrow_mut().encode_header_block(
7371 &mut server.conn,
7372 &headers,
7373 request_stream_id,
7374 );
7375 let hframe = HFrame::Headers {
7376 header_block: encoded_headers.to_vec(),
7377 };
7378
7379 // Send the encoder instructions, but delay them so that the stream is blocked on decoding
7380 // headers.
7381 let encoder_inst_pkt = server.conn.process_output(now());
7382
7383 // Send response
7384 let mut d = Encoder::default();
7385 hframe.encode(&mut d);
7386 let d_frame = HFrame::Data { len: 3 };
7387 d_frame.encode(&mut d);
7388 d.encode(b"abc");
7389 server_send_response_and_exchange_packet(
7390 &mut client,
7391 &mut server,
7392 request_stream_id,
7393 &d,
7394 true,
7395 );
7396
7397 // Let client receive the encoder instructions.
7398 client.process_input(encoder_inst_pkt.dgram().unwrap(), now());
7399
7400 let reset_event = |e| matches!(e, Http3ClientEvent::Reset { stream_id, .. } if stream_id == request_stream_id);
7401 assert!(client.events().any(reset_event));
7402 }
7403
7404 #[test]
7405 fn response_w_101() {
7406 let (mut client, mut server, request_stream_id) = connect_and_send_request(true);
7407
7408 setup_server_side_encoder(&mut client, &mut server);
7409
7410 let mut d = Encoder::default();
7411 let headers1xx = &[Header::new(":status", "101")];
7412 server.encode_headers(request_stream_id, headers1xx, &mut d);
7413
7414 // Send 101 response.
7415 server_send_response_and_exchange_packet(
7416 &mut client,
7417 &mut server,
7418 request_stream_id,
7419 &d,
7420 false,
7421 );
7422
7423 // Stream has been reset because of the 101 response.
7424 let e = client.events().next().unwrap();
7425 assert_eq!(
7426 e,
7427 Http3ClientEvent::Reset {
7428 stream_id: request_stream_id,
7429 error: Error::InvalidHeader.code(),
7430 local: true,
7431 }
7432 );
7433 }
7434 }