Debian Codegraph @

third_party/rust/neqo-http3/src/server.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, RefMut},
9 collections::HashMap,
10 fmt::{self, Display, Formatter},
11 path::PathBuf,
12 rc::Rc,
13 time::Instant,
14 };
15
16 use neqo_common::{qtrace, Datagram};
17 use neqo_crypto::{AntiReplay, Cipher, PrivateKey, PublicKey, ZeroRttChecker};
18 use neqo_transport::{
19 server::{ConnectionRef, Server, ValidateAddress},
20 ConnectionIdGenerator, Output,
21 };
22
23 use crate::{
24 connection::Http3State,
25 connection_server::Http3ServerHandler,
26 server_connection_events::Http3ServerConnEvent,
27 server_events::{
28 Http3OrWebTransportStream, Http3ServerEvent, Http3ServerEvents, WebTransportRequest,
29 },
30 settings::HttpZeroRttChecker,
31 Http3Parameters, Http3StreamInfo, Res,
32 };
33
34 type HandlerRef = Rc<RefCell<Http3ServerHandler>>;
35
36 const MAX_EVENT_DATA_SIZE: usize = 1024;
37
38 pub struct Http3Server {
39 server: Server,
40 http3_parameters: Http3Parameters,
41 http3_handlers: HashMap<ConnectionRef, HandlerRef>,
42 events: Http3ServerEvents,
43 }
44
45 impl Display for Http3Server {
46 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
47 write!(f, "Http3 server ")
48 }
49 }
50
51 impl Http3Server {
52 /// # Errors
53 ///
54 /// Making a `neqo_transport::Server` may produce an error. This can only be a crypto error if
55 /// the socket can't be created or configured.
56 pub fn new(
57 now: Instant,
58 certs: &[impl AsRef<str>],
59 protocols: &[impl AsRef<str>],
60 anti_replay: AntiReplay,
61 cid_manager: Rc<RefCell<dyn ConnectionIdGenerator>>,
62 http3_parameters: Http3Parameters,
63 zero_rtt_checker: Option<Box<dyn ZeroRttChecker>>,
64 ) -> Res<Self> {
65 Ok(Self {
66 server: Server::new(
67 now,
68 certs,
69 protocols,
70 anti_replay,
71 zero_rtt_checker
72 .unwrap_or_else(|| Box::new(HttpZeroRttChecker::new(http3_parameters.clone()))),
73 cid_manager,
74 http3_parameters.get_connection_parameters().clone(),
75 )?,
76 http3_parameters,
77 http3_handlers: HashMap::new(),
78 events: Http3ServerEvents::default(),
79 })
80 }
81
82 pub fn set_qlog_dir(&mut self, dir: Option<PathBuf>) {
83 self.server.set_qlog_dir(dir);
84 }
85
86 pub fn set_validation(&self, v: ValidateAddress) {
87 self.server.set_validation(v);
88 }
89
90 pub fn set_ciphers(&mut self, ciphers: impl AsRef<[Cipher]>) {
91 self.server.set_ciphers(ciphers);
92 }
93
94 /// Enable encrypted client hello (ECH).
95 ///
96 /// # Errors
97 ///
98 /// Only when NSS can't serialize a configuration.
99 pub fn enable_ech(
100 &mut self,
101 config: u8,
102 public_name: &str,
103 sk: &PrivateKey,
104 pk: &PublicKey,
105 ) -> Res<()> {
106 self.server.enable_ech(config, public_name, sk, pk)?;
107 Ok(())
108 }
109
110 #[must_use]
111 pub fn ech_config(&self) -> &[u8] {
112 self.server.ech_config()
113 }
114
115 /// Short-hand for [`Http3Server::process`] with no input datagram.
116 pub fn process_output(&mut self, now: Instant) -> Output {
117 self.process(None::<Datagram>, now)
118 }
119
120 pub fn process(
121 &mut self,
122 dgram: Option<Datagram<impl AsRef<[u8]> + AsMut<[u8]>>>,
123 now: Instant,
124 ) -> Output {
125 qtrace!("[{self}] Process");
126 let out = self.server.process(dgram, now);
127 self.process_http3(now);
128 // If we do not that a dgram already try again after process_http3.
129 match out {
130 Output::Datagram(d) => {
131 qtrace!("[{self}] Send packet: {d:?}");
132 Output::Datagram(d)
133 }
134 _ => self.server.process(Option::<Datagram>::None, now),
135 }
136 }
137
138 /// Process HTTP3 layer.
139 fn process_http3(&mut self, now: Instant) {
140 qtrace!("[{self}] Process http3 internal");
141 #[expect(
142 clippy::mutable_key_type,
143 reason = "ActiveConnectionRef::Hash doesn't access any of the interior mutable types."
144 )]
145 let mut active_conns = self.server.active_connections();
146 active_conns.extend(
147 self.http3_handlers
148 .iter()
149 .filter(|(_, handler)| handler.borrow_mut().should_be_processed())
150 .map(|(c, _)| c)
151 .cloned(),
152 );
153
154 #[expect(
155 clippy::iter_over_hash_type,
156 reason = "OK to loop over active connections in an undefined order."
157 )]
158 for conn in active_conns {
159 self.process_events(&conn, now);
160 }
161 }
162
163 #[expect(
164 clippy::too_many_lines,
165 reason = "Function is mostly a match statement."
166 )]
167 fn process_events(&mut self, conn: &ConnectionRef, now: Instant) {
168 let mut remove = false;
169 let http3_parameters = &self.http3_parameters;
170 {
171 let handler = self.http3_handlers.entry(conn.clone()).or_insert_with(|| {
172 Rc::new(RefCell::new(Http3ServerHandler::new(
173 http3_parameters.clone(),
174 )))
175 });
176 handler
177 .borrow_mut()
178 .process_http3(&mut conn.borrow_mut(), now);
179 let mut handler_borrowed = handler.borrow_mut();
180 while let Some(e) = handler_borrowed.next_event() {
181 match e {
182 Http3ServerConnEvent::Headers {
183 stream_info,
184 headers,
185 fin,
186 } => self.events.headers(
187 Http3OrWebTransportStream::new(
188 conn.clone(),
189 Rc::clone(handler),
190 stream_info,
191 ),
192 headers,
193 fin,
194 ),
195 Http3ServerConnEvent::DataReadable { stream_info } => {
196 prepare_data(
197 stream_info,
198 &mut handler_borrowed,
199 conn,
200 handler,
201 now,
202 &self.events,
203 );
204 }
205 Http3ServerConnEvent::DataWritable { stream_info } => self
206 .events
207 .data_writable(conn.clone(), Rc::clone(handler), stream_info),
208 Http3ServerConnEvent::StreamReset { stream_info, error } => {
209 self.events.stream_reset(
210 conn.clone(),
211 Rc::clone(handler),
212 stream_info,
213 error,
214 );
215 }
216 Http3ServerConnEvent::StreamStopSending { stream_info, error } => {
217 self.events.stream_stop_sending(
218 conn.clone(),
219 Rc::clone(handler),
220 stream_info,
221 error,
222 );
223 }
224 Http3ServerConnEvent::StateChange(state) => {
225 self.events
226 .connection_state_change(conn.clone(), state.clone());
227 if let Http3State::Closed { .. } = state {
228 remove = true;
229 }
230 }
231 Http3ServerConnEvent::PriorityUpdate {
232 stream_id,
233 priority,
234 } => {
235 self.events.priority_update(stream_id, priority);
236 }
237 Http3ServerConnEvent::ExtendedConnect { stream_id, headers } => {
238 self.events.webtransport_new_session(
239 WebTransportRequest::new(conn.clone(), Rc::clone(handler), stream_id),
240 headers,
241 );
242 }
243 Http3ServerConnEvent::ExtendedConnectClosed {
244 stream_id,
245 reason,
246 headers,
247 ..
248 } => self.events.webtransport_session_closed(
249 WebTransportRequest::new(conn.clone(), Rc::clone(handler), stream_id),
250 reason,
251 headers,
252 ),
253 Http3ServerConnEvent::ExtendedConnectNewStream(stream_info) => self
254 .events
255 .webtransport_new_stream(Http3OrWebTransportStream::new(
256 conn.clone(),
257 Rc::clone(handler),
258 stream_info,
259 )),
260 Http3ServerConnEvent::ExtendedConnectDatagram {
261 session_id,
262 datagram,
263 } => self.events.webtransport_datagram(
264 WebTransportRequest::new(conn.clone(), Rc::clone(handler), session_id),
265 datagram,
266 ),
267 }
268 }
269 }
270 if remove {
271 self.http3_handlers.remove(&conn.clone());
272 }
273 }
274
275 /// Get all current events. Best used just in debug/testing code, use
276 /// `next_event` instead.
277 pub fn events(&self) -> impl Iterator<Item = Http3ServerEvent> {
278 self.events.events()
279 }
280
281 /// Return true if there are outstanding events.
282 #[must_use]
283 pub fn has_events(&self) -> bool {
284 self.events.has_events()
285 }
286
287 /// Get events that indicate state changes on the connection. This method
288 /// correctly handles cases where handling one event can obsolete
289 /// previously-queued events, or cause new events to be generated.
290 #[must_use]
291 pub fn next_event(&self) -> Option<Http3ServerEvent> {
292 self.events.next_event()
293 }
294 }
295 fn prepare_data(
296 stream_info: Http3StreamInfo,
297 handler_borrowed: &mut RefMut<Http3ServerHandler>,
298 conn: &ConnectionRef,
299 handler: &HandlerRef,
300 now: Instant,
301 events: &Http3ServerEvents,
302 ) {
303 loop {
304 let mut data = vec![0; MAX_EVENT_DATA_SIZE];
305 let res = handler_borrowed.read_data(
306 &mut conn.borrow_mut(),
307 now,
308 stream_info.stream_id(),
309 &mut data,
310 );
311 if let Ok((amount, fin)) = res {
312 if amount > 0 || fin {
313 if amount < MAX_EVENT_DATA_SIZE {
314 data.resize(amount, 0);
315 }
316
317 events.data(conn.clone(), Rc::clone(handler), stream_info, data, fin);
318 }
319 if amount < MAX_EVENT_DATA_SIZE || fin {
320 break;
321 }
322 } else {
323 // Any error will closed the handler, just ignore this event, the next event must
324 // be a state change event.
325 break;
326 }
327 }
328 }
329
330 #[cfg(test)]
331 mod tests {
332 use std::{
333 collections::HashMap,
334 ops::{Deref, DerefMut},
335 };
336
337 use neqo_common::{event::Provider as _, Encoder};
338 use neqo_crypto::{AuthenticationStatus, ZeroRttCheckResult, ZeroRttChecker};
339 use neqo_qpack::{encoder::QPackEncoder, QpackSettings};
340 use neqo_transport::{
341 CloseReason, Connection, ConnectionEvent, State, StreamId, StreamType, ZeroRttState,
342 };
343 use test_fixture::{
344 anti_replay, default_client, fixture_init, now, CountingConnectionIdGenerator,
345 DEFAULT_ALPN, DEFAULT_KEYS,
346 };
347
348 use super::{Http3Server, Http3ServerEvent, Http3State, Rc, RefCell};
349 use crate::{Error, HFrame, Header, Http3Parameters, Priority};
350
351 const DEFAULT_SETTINGS: QpackSettings = QpackSettings {
352 max_table_size_encoder: 100,
353 max_table_size_decoder: 100,
354 max_blocked_streams: 100,
355 };
356
357 fn http3params(qpack_settings: QpackSettings) -> Http3Parameters {
358 Http3Parameters::default()
359 .max_table_size_encoder(qpack_settings.max_table_size_encoder)
360 .max_table_size_decoder(qpack_settings.max_table_size_decoder)
361 .max_blocked_streams(qpack_settings.max_blocked_streams)
362 }
363
364 pub fn create_server(conn_params: Http3Parameters) -> Http3Server {
365 fixture_init();
366 Http3Server::new(
367 now(),
368 DEFAULT_KEYS,
369 DEFAULT_ALPN,
370 anti_replay(),
371 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
372 conn_params,
373 None,
374 )
375 .expect("create a server")
376 }
377
378 /// Create a http3 server with default configuration.
379 pub fn default_server() -> Http3Server {
380 create_server(http3params(DEFAULT_SETTINGS))
381 }
382
383 fn assert_closed(hconn: &Http3Server, expected: &Error) {
384 let err = CloseReason::Application(expected.code());
385 let closed = |e| matches!(e, Http3ServerEvent::StateChange{ state: Http3State::Closing(e) | Http3State::Closed(e), .. } if e == err);
386 assert!(hconn.events().any(closed));
387 }
388
389 fn assert_connected(hconn: &Http3Server) {
390 let connected = |e| {
391 matches!(
392 e,
393 Http3ServerEvent::StateChange {
394 state: Http3State::Connected,
395 ..
396 }
397 )
398 };
399 assert!(hconn.events().any(connected));
400 }
401
402 fn assert_not_closed(hconn: &Http3Server) {
403 let closed = |e| {
404 matches!(
405 e,
406 Http3ServerEvent::StateChange {
407 state: Http3State::Closing(..),
408 ..
409 }
410 )
411 };
412 assert!(!hconn.events().any(closed));
413 }
414
415 const CLIENT_SIDE_CONTROL_STREAM_ID: StreamId = StreamId::new(2);
416 const CLIENT_SIDE_ENCODER_STREAM_ID: StreamId = StreamId::new(6);
417 const CLIENT_SIDE_DECODER_STREAM_ID: StreamId = StreamId::new(10);
418 const SERVER_SIDE_CONTROL_STREAM_ID: StreamId = StreamId::new(3);
419 const SERVER_SIDE_ENCODER_STREAM_ID: StreamId = StreamId::new(7);
420 const SERVER_SIDE_DECODER_STREAM_ID: StreamId = StreamId::new(11);
421
422 fn connect_transport(server: &mut Http3Server, client: &mut Connection, resume: bool) {
423 let c1 = client.process_output(now());
424 let c11 = client.process_output(now());
425 _ = server.process(c1.dgram(), now());
426 let s1 = server.process(c11.dgram(), now());
427 let c2 = client.process(s1.dgram(), now());
428 let s2 = server.process(c2.dgram(), now());
429 let c2 = client.process(s2.dgram(), now());
430 let needs_auth = client
431 .events()
432 .any(|e| e == ConnectionEvent::AuthenticationNeeded);
433 let c2 = if needs_auth {
434 assert!(!resume);
435 // c2 should just be an ACK, so absorb that.
436 let s_ack = server.process(c2.dgram(), now());
437 assert!(s_ack.dgram().is_none());
438
439 client.authenticated(AuthenticationStatus::Ok, now());
440 client.process_output(now())
441 } else {
442 assert!(resume);
443 c2
444 };
445 assert!(client.state().connected());
446 let s2 = server.process(c2.dgram(), now());
447 assert_connected(server);
448 _ = client.process(s2.dgram(), now());
449 }
450
451 // Start a client/server and check setting frame.
452 fn connect_and_receive_settings_with_server(server: &mut Http3Server) -> Connection {
453 const CONTROL_STREAM_DATA: &[u8] = &[0x0, 0x4, 0x6, 0x1, 0x40, 0x64, 0x7, 0x40, 0x64];
454
455 let mut client = default_client();
456 connect_transport(server, &mut client, false);
457
458 let mut connected = false;
459 while let Some(e) = client.next_event() {
460 match e {
461 ConnectionEvent::NewStream { stream_id } => {
462 assert!(
463 (stream_id == SERVER_SIDE_CONTROL_STREAM_ID)
464 || (stream_id == SERVER_SIDE_ENCODER_STREAM_ID)
465 || (stream_id == SERVER_SIDE_DECODER_STREAM_ID)
466 );
467 assert_eq!(stream_id.stream_type(), StreamType::UniDi);
468 }
469 ConnectionEvent::RecvStreamReadable { stream_id } => {
470 if stream_id == CLIENT_SIDE_CONTROL_STREAM_ID
471 || stream_id == SERVER_SIDE_CONTROL_STREAM_ID
472 {
473 // the control stream
474 let mut buf = [0_u8; 100];
475 let (amount, fin) = client.stream_recv(stream_id, &mut buf).unwrap();
476 assert!(!fin);
477 assert_eq!(amount, CONTROL_STREAM_DATA.len());
478 assert_eq!(&buf[..9], CONTROL_STREAM_DATA);
479 } else if stream_id == CLIENT_SIDE_ENCODER_STREAM_ID
480 || stream_id == SERVER_SIDE_ENCODER_STREAM_ID
481 {
482 let mut buf = [0_u8; 100];
483 let (amount, fin) = client.stream_recv(stream_id, &mut buf).unwrap();
484 assert!(!fin);
485 assert_eq!(amount, 1);
486 assert_eq!(buf[..1], [0x2]);
487 } else if stream_id == CLIENT_SIDE_DECODER_STREAM_ID
488 || stream_id == SERVER_SIDE_DECODER_STREAM_ID
489 {
490 let mut buf = [0_u8; 100];
491 let (amount, fin) = client.stream_recv(stream_id, &mut buf).unwrap();
492 assert!(!fin);
493 assert_eq!(amount, 1);
494 assert_eq!(buf[..1], [0x3]);
495 } else {
496 panic!("unexpected event");
497 }
498 }
499 ConnectionEvent::SendStreamWritable { stream_id } => {
500 assert!(
501 (stream_id == CLIENT_SIDE_CONTROL_STREAM_ID)
502 || (stream_id == CLIENT_SIDE_ENCODER_STREAM_ID)
503 || (stream_id == CLIENT_SIDE_DECODER_STREAM_ID)
504 );
505 }
506 ConnectionEvent::StateChange(State::Connected) => connected = true,
507 ConnectionEvent::StateChange(_) | ConnectionEvent::SendStreamCreatable { .. } => (),
508 _ => panic!("unexpected event"),
509 }
510 }
511 assert!(connected);
512 client
513 }
514
515 fn connect_and_receive_settings() -> (Http3Server, Connection) {
516 // Create a server and connect it to a client.
517 // We will have a http3 server on one side and a neqo_transport
518 // connection on the other side so that we can check what the http3
519 // side sends and also to simulate an incorrectly behaving http3
520 // client.
521
522 let mut server = default_server();
523 let client = connect_and_receive_settings_with_server(&mut server);
524 (server, client)
525 }
526
527 // Test http3 connection initialization.
528 // The server will open the control and qpack streams and send SETTINGS frame.
529 #[test]
530 fn server_connect() {
531 drop(connect_and_receive_settings());
532 }
533
534 struct PeerConnection {
535 conn: Connection,
536 control_stream_id: StreamId,
537 }
538
539 impl PeerConnection {
540 /// A shortcut for sending on the control stream.
541 fn control_send(&mut self, data: &[u8]) {
542 let res = self.conn.stream_send(self.control_stream_id, data);
543 assert_eq!(res, Ok(data.len()));
544 }
545 }
546
547 impl Deref for PeerConnection {
548 type Target = Connection;
549 fn deref(&self) -> &Self::Target {
550 &self.conn
551 }
552 }
553
554 impl DerefMut for PeerConnection {
555 fn deref_mut(&mut self) -> &mut Self::Target {
556 &mut self.conn
557 }
558 }
559
560 // Connect transport, send and receive settings.
561 fn connect_to(server: &mut Http3Server) -> PeerConnection {
562 let mut neqo_trans_conn = connect_and_receive_settings_with_server(server);
563 let control_stream = neqo_trans_conn.stream_create(StreamType::UniDi).unwrap();
564 let mut sent = neqo_trans_conn.stream_send(
565 control_stream,
566 &[0x0, 0x4, 0x6, 0x1, 0x40, 0x64, 0x7, 0x40, 0x64],
567 );
568 assert_eq!(sent, Ok(9));
569 let mut encoder = QPackEncoder::new(
570 &QpackSettings {
571 max_table_size_encoder: 100,
572 max_table_size_decoder: 0,
573 max_blocked_streams: 0,
574 },
575 true,
576 );
577 encoder.add_send_stream(neqo_trans_conn.stream_create(StreamType::UniDi).unwrap());
578 encoder.send_encoder_updates(&mut neqo_trans_conn).unwrap();
579 let decoder_stream = neqo_trans_conn.stream_create(StreamType::UniDi).unwrap();
580 sent = neqo_trans_conn.stream_send(decoder_stream, &[0x3]);
581 assert_eq!(sent, Ok(1));
582 let out1 = neqo_trans_conn.process_output(now());
583 let out2 = server.process(out1.dgram(), now());
584 drop(neqo_trans_conn.process(out2.dgram(), now()));
585
586 // assert no error occurred.
587 assert_not_closed(server);
588
589 PeerConnection {
590 conn: neqo_trans_conn,
591 control_stream_id: control_stream,
592 }
593 }
594
595 fn connect() -> (Http3Server, PeerConnection) {
596 let mut server = default_server();
597 let client = connect_to(&mut server);
598 (server, client)
599 }
600
601 // Server: Test receiving a new control stream and a SETTINGS frame.
602 #[test]
603 fn server_receive_control_frame() {
604 drop(connect());
605 }
606
607 // Server: Test that the connection will be closed if control stream
608 // has been closed.
609 #[test]
610 fn server_close_control_stream() {
611 let (mut hconn, mut peer_conn) = connect();
612 let control = peer_conn.control_stream_id;
613 peer_conn.stream_close_send(control).unwrap();
614 let out = peer_conn.process_output(now());
615 hconn.process(out.dgram(), now());
616 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
617 }
618
619 // Server: test missing SETTINGS frame
620 // (the first frame sent is a MAX_PUSH_ID frame).
621 #[test]
622 fn server_missing_settings() {
623 let (mut hconn, mut neqo_trans_conn) = connect_and_receive_settings();
624 // Create client control stream.
625 let control_stream = neqo_trans_conn.stream_create(StreamType::UniDi).unwrap();
626 // Send a MAX_PUSH_ID frame instead.
627 let sent = neqo_trans_conn.stream_send(control_stream, &[0x0, 0xd, 0x1, 0xf]);
628 assert_eq!(sent, Ok(4));
629 let out = neqo_trans_conn.process_output(now());
630 hconn.process(out.dgram(), now());
631 assert_closed(&hconn, &Error::HttpMissingSettings);
632 }
633
634 // Server: receiving SETTINGS frame twice causes connection close
635 // with error HTTP_UNEXPECTED_FRAME.
636 #[test]
637 fn server_receive_settings_twice() {
638 let (mut hconn, mut peer_conn) = connect();
639 // send the second SETTINGS frame.
640 peer_conn.control_send(&[0x4, 0x6, 0x1, 0x40, 0x64, 0x7, 0x40, 0x64]);
641 let out = peer_conn.process_output(now());
642 hconn.process(out.dgram(), now());
643 assert_closed(&hconn, &Error::HttpFrameUnexpected);
644 }
645
646 fn priority_update_check_id(stream_id: StreamId, valid: bool) {
647 let (mut hconn, mut peer_conn) = connect();
648 // send a priority update
649 let frame = HFrame::PriorityUpdateRequest {
650 element_id: stream_id.as_u64(),
651 priority: Priority::default(),
652 };
653 let mut e = Encoder::default();
654 frame.encode(&mut e);
655 peer_conn.control_send(e.as_ref());
656 let out = peer_conn.process_output(now());
657 hconn.process(out.dgram(), now());
658 // check if the given connection got closed on invalid stream ids
659 if valid {
660 assert_not_closed(&hconn);
661 } else {
662 assert_closed(&hconn, &Error::HttpId);
663 }
664 }
665
666 #[test]
667 fn priority_update_valid_id_0() {
668 // Client-Initiated, Bidirectional
669 priority_update_check_id(StreamId::new(0), true);
670 }
671 #[test]
672 fn priority_update_invalid_id_1() {
673 // Server-Initiated, Bidirectional
674 priority_update_check_id(StreamId::new(1), false);
675 }
676 #[test]
677 fn priority_update_invalid_id_2() {
678 // Client-Initiated, Unidirectional
679 priority_update_check_id(StreamId::new(2), false);
680 }
681 #[test]
682 fn priority_update_invalid_id_3() {
683 // Server-Initiated, Unidirectional
684 priority_update_check_id(StreamId::new(3), false);
685 }
686
687 #[test]
688 fn priority_update_invalid_large_id() {
689 // Server-Initiated, Unidirectional (divisible by 4)
690 priority_update_check_id(StreamId::new(1_000_000_000), false);
691 }
692
693 fn test_wrong_frame_on_control_stream(v: &[u8]) {
694 let (mut hconn, mut peer_conn) = connect();
695
696 // receive a frame that is not allowed on the control stream.
697 peer_conn.control_send(v);
698
699 let out = peer_conn.process_output(now());
700 hconn.process(out.dgram(), now());
701 assert_closed(&hconn, &Error::HttpFrameUnexpected);
702 }
703
704 // send DATA frame on a control stream
705 #[test]
706 fn server_data_frame_on_control_stream() {
707 test_wrong_frame_on_control_stream(&[0x0, 0x2, 0x1, 0x2]);
708 }
709
710 // send HEADERS frame on a control stream
711 #[test]
712 fn server_headers_frame_on_control_stream() {
713 test_wrong_frame_on_control_stream(&[0x1, 0x2, 0x1, 0x2]);
714 }
715
716 // send PUSH_PROMISE frame on a control stream
717 #[test]
718 fn server_push_promise_frame_on_control_stream() {
719 test_wrong_frame_on_control_stream(&[0x5, 0x2, 0x1, 0x2]);
720 }
721
722 // Server: receive unknown stream type
723 // also test getting stream id that does not fit into a single byte.
724 #[test]
725 fn server_received_unknown_stream() {
726 let (mut hconn, mut peer_conn) = connect();
727
728 // create a stream with unknown type.
729 let new_stream_id = peer_conn.stream_create(StreamType::UniDi).unwrap();
730 _ = peer_conn
731 .stream_send(new_stream_id, &[0x41, 0x19, 0x4, 0x4, 0x6, 0x0, 0x8, 0x0])
732 .unwrap();
733 let out = peer_conn.process_output(now());
734 let out = hconn.process(out.dgram(), now());
735 drop(peer_conn.process(out.dgram(), now()));
736 let out = hconn.process_output(now());
737 drop(peer_conn.process(out.dgram(), now()));
738
739 // check for stop-sending with Error::HttpStreamCreation.
740 let mut stop_sending_event_found = false;
741 while let Some(e) = peer_conn.next_event() {
742 if let ConnectionEvent::SendStreamStopSending {
743 stream_id,
744 app_error,
745 } = e
746 {
747 stop_sending_event_found = true;
748 assert_eq!(stream_id, new_stream_id);
749 assert_eq!(app_error, Error::HttpStreamCreation.code());
750 }
751 }
752 assert!(stop_sending_event_found);
753 assert_not_closed(&hconn);
754 }
755
756 // Server: receiving a push stream on a server should cause WrongStreamDirection
757 #[test]
758 fn server_received_push_stream() {
759 let (mut hconn, mut peer_conn) = connect();
760
761 // create a push stream.
762 let push_stream_id = peer_conn.stream_create(StreamType::UniDi).unwrap();
763 _ = peer_conn.stream_send(push_stream_id, &[0x1]).unwrap();
764 let out = peer_conn.process_output(now());
765 let out = hconn.process(out.dgram(), now());
766 drop(peer_conn.conn.process(out.dgram(), now()));
767 assert_closed(&hconn, &Error::HttpStreamCreation);
768 }
769
770 /// Test reading of a slowly streamed frame. bytes are received one by one
771 #[test]
772 fn server_frame_reading() {
773 let (mut hconn, mut peer_conn) = connect_and_receive_settings();
774
775 // create a control stream.
776 let control_stream = peer_conn.stream_create(StreamType::UniDi).unwrap();
777
778 // send the stream type
779 let mut sent = peer_conn.stream_send(control_stream, &[0x0]);
780 assert_eq!(sent, Ok(1));
781 let out = peer_conn.process_output(now());
782 hconn.process(out.dgram(), now());
783
784 // start sending SETTINGS frame
785 sent = peer_conn.stream_send(control_stream, &[0x4]);
786 assert_eq!(sent, Ok(1));
787 let out = peer_conn.process_output(now());
788 hconn.process(out.dgram(), now());
789
790 sent = peer_conn.stream_send(control_stream, &[0x4]);
791 assert_eq!(sent, Ok(1));
792 let out = peer_conn.process_output(now());
793 hconn.process(out.dgram(), now());
794
795 sent = peer_conn.stream_send(control_stream, &[0x6]);
796 assert_eq!(sent, Ok(1));
797 let out = peer_conn.process_output(now());
798 hconn.process(out.dgram(), now());
799
800 sent = peer_conn.stream_send(control_stream, &[0x0]);
801 assert_eq!(sent, Ok(1));
802 let out = peer_conn.process_output(now());
803 hconn.process(out.dgram(), now());
804
805 sent = peer_conn.stream_send(control_stream, &[0x8]);
806 assert_eq!(sent, Ok(1));
807 let out = peer_conn.process_output(now());
808 hconn.process(out.dgram(), now());
809
810 sent = peer_conn.stream_send(control_stream, &[0x0]);
811 assert_eq!(sent, Ok(1));
812 let out = peer_conn.process_output(now());
813 hconn.process(out.dgram(), now());
814
815 assert_not_closed(&hconn);
816
817 // Now test PushPromise
818 sent = peer_conn.stream_send(control_stream, &[0x5]);
819 assert_eq!(sent, Ok(1));
820 let out = peer_conn.process_output(now());
821 hconn.process(out.dgram(), now());
822
823 sent = peer_conn.stream_send(control_stream, &[0x5]);
824 assert_eq!(sent, Ok(1));
825 let out = peer_conn.process_output(now());
826 hconn.process(out.dgram(), now());
827
828 sent = peer_conn.stream_send(control_stream, &[0x4]);
829 assert_eq!(sent, Ok(1));
830 let out = peer_conn.process_output(now());
831 hconn.process(out.dgram(), now());
832
833 sent = peer_conn.stream_send(control_stream, &[0x61]);
834 assert_eq!(sent, Ok(1));
835 let out = peer_conn.process_output(now());
836 hconn.process(out.dgram(), now());
837
838 sent = peer_conn.stream_send(control_stream, &[0x62]);
839 assert_eq!(sent, Ok(1));
840 let out = peer_conn.process_output(now());
841 hconn.process(out.dgram(), now());
842
843 sent = peer_conn.stream_send(control_stream, &[0x63]);
844 assert_eq!(sent, Ok(1));
845 let out = peer_conn.process_output(now());
846 hconn.process(out.dgram(), now());
847
848 sent = peer_conn.stream_send(control_stream, &[0x64]);
849 assert_eq!(sent, Ok(1));
850 let out = peer_conn.process_output(now());
851 hconn.process(out.dgram(), now());
852
853 // PUSH_PROMISE on a control stream will cause an error
854 assert_closed(&hconn, &Error::HttpFrameUnexpected);
855 }
856
857 // Test reading of a slowly streamed frame. bytes are received one by one
858 fn test_incomplete_frame(res: &[u8]) {
859 let (mut hconn, mut peer_conn) = connect_and_receive_settings();
860
861 // send an incomplete request.
862 let stream_id = peer_conn.stream_create(StreamType::BiDi).unwrap();
863 peer_conn.stream_send(stream_id, res).unwrap();
864 peer_conn.stream_close_send(stream_id).unwrap();
865
866 let out = peer_conn.process_output(now());
867 hconn.process(out.dgram(), now());
868
869 assert_closed(&hconn, &Error::HttpFrame);
870 }
871
872 const REQUEST_WITH_BODY: &[u8] = &[
873 // headers
874 0x01, 0x10, 0x00, 0x00, 0xd1, 0xd7, 0x50, 0x89, 0x41, 0xe9, 0x2a, 0x67, 0x35, 0x53, 0x2e,
875 0x43, 0xd3, 0xc1, // the first data frame.
876 0x0, 0x3, 0x61, 0x62, 0x63, // the second data frame.
877 0x0, 0x3, 0x64, 0x65, 0x66,
878 ];
879 const REQUEST_BODY: &[u8] = &[0x61, 0x62, 0x63, 0x64, 0x65, 0x66];
880
881 const RESPONSE_BODY: &[u8] = &[0x67, 0x68, 0x69];
882
883 fn check_request_header(header: &[Header]) {
884 let expected_request_header = &[
885 Header::new(":method", "GET"),
886 Header::new(":scheme", "https"),
887 Header::new(":authority", "something.com"),
888 Header::new(":path", "/"),
889 ];
890 assert_eq!(header, expected_request_header);
891 }
892
893 // Incomplete DATA frame
894 #[test]
895 fn server_incomplete_data_frame() {
896 test_incomplete_frame(&REQUEST_WITH_BODY[..22]);
897 }
898
899 // Incomplete HEADERS frame
900 #[test]
901 fn server_incomplete_headers_frame() {
902 test_incomplete_frame(&REQUEST_WITH_BODY[..10]);
903 }
904
905 #[test]
906 fn server_incomplete_unknown_frame() {
907 test_incomplete_frame(&[0x21]);
908 }
909
910 #[test]
911 fn server_request_with_body() {
912 let (mut hconn, mut peer_conn) = connect();
913
914 let stream_id = peer_conn.stream_create(StreamType::BiDi).unwrap();
915 peer_conn.stream_send(stream_id, REQUEST_WITH_BODY).unwrap();
916 peer_conn.stream_close_send(stream_id).unwrap();
917
918 let out = peer_conn.process_output(now());
919 hconn.process(out.dgram(), now());
920
921 // Check connection event. There should be 1 Header and 2 data events.
922 let mut headers_frames = 0;
923 let mut data_received = 0;
924 while let Some(event) = hconn.next_event() {
925 match event {
926 Http3ServerEvent::Headers { headers, fin, .. } => {
927 check_request_header(&headers);
928 assert!(!fin);
929 headers_frames += 1;
930 }
931 Http3ServerEvent::Data { stream, data, fin } => {
932 assert_eq!(data, REQUEST_BODY);
933 assert!(fin);
934 stream
935 .send_headers(&[
936 Header::new(":status", "200"),
937 Header::new("content-length", "3"),
938 ])
939 .unwrap();
940 stream.send_data(RESPONSE_BODY).unwrap();
941 data_received += 1;
942 }
943 Http3ServerEvent::DataWritable { .. }
944 | Http3ServerEvent::StreamReset { .. }
945 | Http3ServerEvent::StreamStopSending { .. }
946 | Http3ServerEvent::StateChange { .. }
947 | Http3ServerEvent::PriorityUpdate { .. }
948 | Http3ServerEvent::WebTransport(_) => {}
949 }
950 }
951 assert_eq!(headers_frames, 1);
952 assert_eq!(data_received, 1);
953 }
954
955 #[test]
956 fn server_request_with_body_send_stop_sending() {
957 let (mut hconn, mut peer_conn) = connect();
958
959 let stream_id = peer_conn.stream_create(StreamType::BiDi).unwrap();
960 // Send only request headers for now.
961 peer_conn
962 .stream_send(stream_id, &REQUEST_WITH_BODY[..20])
963 .unwrap();
964
965 let out = peer_conn.process_output(now());
966 hconn.process(out.dgram(), now());
967
968 // Check connection event. There should be 1 Header and no data events.
969 let mut headers_frames = 0;
970 while let Some(event) = hconn.next_event() {
971 match event {
972 Http3ServerEvent::Headers {
973 stream,
974 headers,
975 fin,
976 } => {
977 check_request_header(&headers);
978 assert!(!fin);
979 headers_frames += 1;
980 stream
981 .stream_stop_sending(Error::HttpNoError.code())
982 .unwrap();
983 stream
984 .send_headers(&[
985 Header::new(":status", "200"),
986 Header::new("content-length", "3"),
987 ])
988 .unwrap();
989 stream.send_data(RESPONSE_BODY).unwrap();
990 }
991 Http3ServerEvent::Data { .. } => {
992 panic!("We should not have a Data event");
993 }
994 Http3ServerEvent::DataWritable { .. }
995 | Http3ServerEvent::StreamReset { .. }
996 | Http3ServerEvent::StreamStopSending { .. }
997 | Http3ServerEvent::StateChange { .. }
998 | Http3ServerEvent::PriorityUpdate { .. }
999 | Http3ServerEvent::WebTransport(_) => {}
1000 }
1001 }
1002 let out = hconn.process_output(now());
1003
1004 // Send data.
1005 peer_conn
1006 .stream_send(stream_id, &REQUEST_WITH_BODY[20..])
1007 .unwrap();
1008 peer_conn.stream_close_send(stream_id).unwrap();
1009
1010 let out = peer_conn.process(out.dgram(), now());
1011 hconn.process(out.dgram(), now());
1012
1013 while let Some(event) = hconn.next_event() {
1014 match event {
1015 Http3ServerEvent::Headers { .. } => {
1016 panic!("We should not have a Header event");
1017 }
1018 Http3ServerEvent::Data { .. } => {
1019 panic!("We should not have a Data event");
1020 }
1021 Http3ServerEvent::DataWritable { .. }
1022 | Http3ServerEvent::StreamReset { .. }
1023 | Http3ServerEvent::StreamStopSending { .. }
1024 | Http3ServerEvent::StateChange { .. }
1025 | Http3ServerEvent::PriorityUpdate { .. }
1026 | Http3ServerEvent::WebTransport(_) => {}
1027 }
1028 }
1029 assert_eq!(headers_frames, 1);
1030 }
1031
1032 #[test]
1033 fn server_request_with_body_server_reset() {
1034 let (mut hconn, mut peer_conn) = connect();
1035
1036 let request_stream_id = peer_conn.stream_create(StreamType::BiDi).unwrap();
1037 // Send only request headers for now.
1038 peer_conn
1039 .stream_send(request_stream_id, &REQUEST_WITH_BODY[..20])
1040 .unwrap();
1041
1042 let out = peer_conn.process_output(now());
1043 hconn.process(out.dgram(), now());
1044
1045 // Check connection event. There should be 1 Header and no data events.
1046 // The server will reset the stream.
1047 let mut headers_frames = 0;
1048 while let Some(event) = hconn.next_event() {
1049 match event {
1050 Http3ServerEvent::Headers {
1051 stream,
1052 headers,
1053 fin,
1054 } => {
1055 check_request_header(&headers);
1056 assert!(!fin);
1057 headers_frames += 1;
1058 stream
1059 .cancel_fetch(Error::HttpRequestRejected.code())
1060 .unwrap();
1061 }
1062 Http3ServerEvent::Data { .. } => {
1063 panic!("We should not have a Data event");
1064 }
1065 Http3ServerEvent::DataWritable { .. }
1066 | Http3ServerEvent::StreamReset { .. }
1067 | Http3ServerEvent::StreamStopSending { .. }
1068 | Http3ServerEvent::StateChange { .. }
1069 | Http3ServerEvent::PriorityUpdate { .. }
1070 | Http3ServerEvent::WebTransport(_) => {}
1071 }
1072 }
1073 let out = hconn.process_output(now());
1074
1075 let out = peer_conn.process(out.dgram(), now());
1076 hconn.process(out.dgram(), now());
1077
1078 // Check that STOP_SENDING and REET has been received.
1079 let mut reset = 0;
1080 let mut stop_sending = 0;
1081 while let Some(event) = peer_conn.next_event() {
1082 match event {
1083 ConnectionEvent::RecvStreamReset { stream_id, .. } => {
1084 assert_eq!(request_stream_id, stream_id);
1085 reset += 1;
1086 }
1087 ConnectionEvent::SendStreamStopSending { stream_id, .. } => {
1088 assert_eq!(request_stream_id, stream_id);
1089 stop_sending += 1;
1090 }
1091 _ => {}
1092 }
1093 }
1094 assert_eq!(headers_frames, 1);
1095 assert_eq!(reset, 1);
1096 assert_eq!(stop_sending, 1);
1097 }
1098
1099 // Server: Test that the connection will be closed if the local control stream
1100 // has been reset.
1101 #[test]
1102 fn server_reset_control_stream() {
1103 let (mut hconn, mut peer_conn) = connect();
1104 peer_conn
1105 .stream_reset_send(CLIENT_SIDE_CONTROL_STREAM_ID, Error::HttpNoError.code())
1106 .unwrap();
1107 let out = peer_conn.process_output(now());
1108 hconn.process(out.dgram(), now());
1109 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
1110 }
1111
1112 // Server: Test that the connection will be closed if the client side encoder stream
1113 // has been reset.
1114 #[test]
1115 fn server_reset_client_side_encoder_stream() {
1116 let (mut hconn, mut peer_conn) = connect();
1117 peer_conn
1118 .stream_reset_send(CLIENT_SIDE_ENCODER_STREAM_ID, Error::HttpNoError.code())
1119 .unwrap();
1120 let out = peer_conn.process_output(now());
1121 hconn.process(out.dgram(), now());
1122 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
1123 }
1124
1125 // Server: Test that the connection will be closed if the client side decoder stream
1126 // has been reset.
1127 #[test]
1128 fn server_reset_client_side_decoder_stream() {
1129 let (mut hconn, mut peer_conn) = connect();
1130 peer_conn
1131 .stream_reset_send(CLIENT_SIDE_DECODER_STREAM_ID, Error::HttpNoError.code())
1132 .unwrap();
1133 let out = peer_conn.process_output(now());
1134 hconn.process(out.dgram(), now());
1135 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
1136 }
1137
1138 // Server: Test that the connection will be closed if the local control stream
1139 // has received a stop_sending.
1140 #[test]
1141 fn client_stop_sending_control_stream() {
1142 let (mut hconn, mut peer_conn) = connect();
1143
1144 peer_conn
1145 .stream_stop_sending(SERVER_SIDE_CONTROL_STREAM_ID, Error::HttpNoError.code())
1146 .unwrap();
1147 let out = peer_conn.process_output(now());
1148 hconn.process(out.dgram(), now());
1149 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
1150 }
1151
1152 // Server: Test that the connection will be closed if the server side encoder stream
1153 // has received a stop_sending.
1154 #[test]
1155 fn server_stop_sending_encoder_stream() {
1156 let (mut hconn, mut peer_conn) = connect();
1157 peer_conn
1158 .stream_stop_sending(SERVER_SIDE_ENCODER_STREAM_ID, Error::HttpNoError.code())
1159 .unwrap();
1160 let out = peer_conn.process_output(now());
1161 hconn.process(out.dgram(), now());
1162 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
1163 }
1164
1165 // Server: Test that the connection will be closed if the server side decoder stream
1166 // has received a stop_sending.
1167 #[test]
1168 fn server_stop_sending_decoder_stream() {
1169 let (mut hconn, mut peer_conn) = connect();
1170 peer_conn
1171 .stream_stop_sending(SERVER_SIDE_DECODER_STREAM_ID, Error::HttpNoError.code())
1172 .unwrap();
1173 let out = peer_conn.process_output(now());
1174 hconn.process(out.dgram(), now());
1175 assert_closed(&hconn, &Error::HttpClosedCriticalStream);
1176 }
1177
1178 /// Perform a handshake, then another with the token from the first.
1179 /// The second should always resume, but it might not always accept early data.
1180 fn zero_rtt_with_settings(conn_params: Http3Parameters, zero_rtt: ZeroRttState) {
1181 let (_, mut client) = connect();
1182 let token = client.events().find_map(|e| {
1183 if let ConnectionEvent::ResumptionToken(token) = e {
1184 Some(token)
1185 } else {
1186 None
1187 }
1188 });
1189 assert!(token.is_some());
1190
1191 let mut server = create_server(conn_params);
1192 let mut client = default_client();
1193 client.enable_resumption(now(), token.unwrap()).unwrap();
1194
1195 connect_transport(&mut server, &mut client, true);
1196 assert!(client.tls_info().unwrap().resumed());
1197 assert_eq!(client.zero_rtt_state(), zero_rtt);
1198 }
1199
1200 #[test]
1201 fn zero_rtt() {
1202 zero_rtt_with_settings(http3params(DEFAULT_SETTINGS), ZeroRttState::AcceptedClient);
1203 }
1204
1205 /// A larger QPACK decoder table size isn't an impediment to 0-RTT.
1206 #[test]
1207 fn zero_rtt_larger_decoder_table() {
1208 zero_rtt_with_settings(
1209 http3params(QpackSettings {
1210 max_table_size_decoder: DEFAULT_SETTINGS.max_table_size_decoder + 1,
1211 ..DEFAULT_SETTINGS
1212 }),
1213 ZeroRttState::AcceptedClient,
1214 );
1215 }
1216
1217 /// A smaller QPACK decoder table size prevents 0-RTT.
1218 #[test]
1219 fn zero_rtt_smaller_decoder_table() {
1220 zero_rtt_with_settings(
1221 http3params(QpackSettings {
1222 max_table_size_decoder: DEFAULT_SETTINGS.max_table_size_decoder - 1,
1223 ..DEFAULT_SETTINGS
1224 }),
1225 ZeroRttState::Rejected,
1226 );
1227 }
1228
1229 /// More blocked streams does not prevent 0-RTT.
1230 #[test]
1231 fn zero_rtt_more_blocked_streams() {
1232 zero_rtt_with_settings(
1233 http3params(QpackSettings {
1234 max_blocked_streams: DEFAULT_SETTINGS.max_blocked_streams + 1,
1235 ..DEFAULT_SETTINGS
1236 }),
1237 ZeroRttState::AcceptedClient,
1238 );
1239 }
1240
1241 /// A lower number of blocked streams also prevents 0-RTT.
1242 #[test]
1243 fn zero_rtt_fewer_blocked_streams() {
1244 zero_rtt_with_settings(
1245 http3params(QpackSettings {
1246 max_blocked_streams: DEFAULT_SETTINGS.max_blocked_streams - 1,
1247 ..DEFAULT_SETTINGS
1248 }),
1249 ZeroRttState::Rejected,
1250 );
1251 }
1252
1253 /// The size of the encoder table is local and therefore doesn't prevent 0-RTT.
1254 #[test]
1255 fn zero_rtt_smaller_encoder_table() {
1256 zero_rtt_with_settings(
1257 http3params(QpackSettings {
1258 max_table_size_encoder: DEFAULT_SETTINGS.max_table_size_encoder - 1,
1259 ..DEFAULT_SETTINGS
1260 }),
1261 ZeroRttState::AcceptedClient,
1262 );
1263 }
1264
1265 #[test]
1266 fn client_request_hash() {
1267 let (mut hconn, mut peer_conn) = connect();
1268
1269 let request_stream_id_1 = peer_conn.stream_create(StreamType::BiDi).unwrap();
1270 // Send only request headers for now.
1271 peer_conn
1272 .stream_send(request_stream_id_1, REQUEST_WITH_BODY)
1273 .unwrap();
1274
1275 let request_stream_id_2 = peer_conn.stream_create(StreamType::BiDi).unwrap();
1276 // Send only request headers for now.
1277 peer_conn
1278 .stream_send(request_stream_id_2, REQUEST_WITH_BODY)
1279 .unwrap();
1280
1281 let out = peer_conn.process_output(now());
1282 hconn.process(out.dgram(), now());
1283
1284 let mut requests = HashMap::new();
1285 while let Some(event) = hconn.next_event() {
1286 match event {
1287 Http3ServerEvent::Headers { stream, .. } => {
1288 assert!(!requests.contains_key(&stream.stream_id()));
1289 requests.insert(stream.stream_id(), 0);
1290 }
1291 Http3ServerEvent::Data { stream, .. } => {
1292 assert!(requests.contains_key(&stream.stream_id()));
1293 }
1294 Http3ServerEvent::DataWritable { .. }
1295 | Http3ServerEvent::StreamReset { .. }
1296 | Http3ServerEvent::StreamStopSending { .. }
1297 | Http3ServerEvent::StateChange { .. }
1298 | Http3ServerEvent::PriorityUpdate { .. }
1299 | Http3ServerEvent::WebTransport(_) => {}
1300 }
1301 }
1302 assert_eq!(requests.len(), 2);
1303 }
1304
1305 #[derive(Debug, Default)]
1306 pub struct RejectZeroRtt {}
1307 impl ZeroRttChecker for RejectZeroRtt {
1308 fn check(&self, _token: &[u8]) -> ZeroRttCheckResult {
1309 ZeroRttCheckResult::Reject
1310 }
1311 }
1312
1313 #[test]
1314 fn reject_zero_server() {
1315 fixture_init();
1316 let mut server = Http3Server::new(
1317 now(),
1318 DEFAULT_KEYS,
1319 DEFAULT_ALPN,
1320 anti_replay(),
1321 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
1322 http3params(DEFAULT_SETTINGS),
1323 Some(Box::<RejectZeroRtt>::default()),
1324 )
1325 .expect("create a server");
1326 let mut client = connect_to(&mut server);
1327 let token = client.events().find_map(|e| {
1328 if let ConnectionEvent::ResumptionToken(token) = e {
1329 Some(token)
1330 } else {
1331 None
1332 }
1333 });
1334 assert!(token.is_some());
1335
1336 let mut client = default_client();
1337 client.enable_resumption(now(), token.unwrap()).unwrap();
1338
1339 connect_transport(&mut server, &mut client, true);
1340 assert!(client.tls_info().unwrap().resumed());
1341 assert_eq!(client.zero_rtt_state(), ZeroRttState::Rejected);
1342 }
1343 }