Debian Codegraph @

third_party/rust/neqo-http3/src/features/extended_connect/tests/webtransport/mod.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 mod datagrams;
8 mod negotiation;
9 mod sessions;
10 mod streams;
11 use std::{cell::RefCell, rc::Rc, time::Duration};
12
13 use neqo_common::{event::Provider as _, header::HeadersExt as _};
14 use neqo_crypto::AuthenticationStatus;
15 use neqo_transport::{ConnectionParameters, Pmtud, StreamId, StreamType};
16 use test_fixture::{
17 anti_replay, fixture_init, now, CountingConnectionIdGenerator, DEFAULT_ADDR, DEFAULT_ALPN_H3,
18 DEFAULT_KEYS, DEFAULT_SERVER_NAME,
19 };
20
21 use crate::{
22 features::extended_connect::SessionCloseReason, Error, Header, Http3Client, Http3ClientEvent,
23 Http3OrWebTransportStream, Http3Parameters, Http3Server, Http3ServerEvent, Http3State,
24 RecvStreamStats, SendStreamStats, WebTransportEvent, WebTransportRequest,
25 WebTransportServerEvent, WebTransportSessionAcceptAction,
26 };
27
28 // Leave space for large QUIC header.
29 const DATAGRAM_SIZE: u64 = Pmtud::default_plpmtu(DEFAULT_ADDR.ip()) as u64 - 40;
30
31 pub fn wt_default_parameters() -> Http3Parameters {
32 Http3Parameters::default()
33 .webtransport(true)
34 .connection_parameters(ConnectionParameters::default().datagram_size(DATAGRAM_SIZE))
35 }
36
37 pub fn default_http3_client(client_params: Http3Parameters) -> Http3Client {
38 fixture_init();
39 Http3Client::new(
40 DEFAULT_SERVER_NAME,
41 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
42 DEFAULT_ADDR,
43 DEFAULT_ADDR,
44 client_params,
45 now(),
46 )
47 .expect("create a default client")
48 }
49
50 pub fn default_http3_server(server_params: Http3Parameters) -> Http3Server {
51 Http3Server::new(
52 now(),
53 DEFAULT_KEYS,
54 DEFAULT_ALPN_H3,
55 anti_replay(),
56 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
57 server_params,
58 None,
59 )
60 .expect("create a server")
61 }
62
63 pub fn assert_wt(headers: &[Header]) {
64 assert!(
65 headers.contains_header(":method", "CONNECT")
66 && headers.contains_header(":protocol", "webtransport")
67 );
68 }
69
70 fn exchange_packets(client: &mut Http3Client, server: &mut Http3Server) {
71 let mut out = None;
72 loop {
73 out = client.process(out, now()).dgram();
74 out = server.process(out, now()).dgram();
75 if out.is_none() {
76 break;
77 }
78 }
79 }
80
81 // Perform only QUIC transport handshake.
82 fn connect_with(client: &mut Http3Client, server: &mut Http3Server) {
83 assert_eq!(client.state(), Http3State::Initializing);
84 let out = client.process_output(now());
85 let out2 = client.process_output(now());
86 assert_eq!(client.state(), Http3State::Initializing);
87
88 _ = server.process(out.dgram(), now());
89 let out = server.process(out2.dgram(), now());
90 let out = client.process(out.dgram(), now());
91 let out = server.process(out.dgram(), now());
92 let out = client.process(out.dgram(), now());
93 let out = server.process(out.dgram(), now());
94 assert!(out.as_dgram_ref().is_none());
95
96 let authentication_needed = |e| matches!(e, Http3ClientEvent::AuthenticationNeeded);
97 assert!(client.events().any(authentication_needed));
98 client.authenticated(AuthenticationStatus::Ok, now());
99
100 let out = client.process(out.dgram(), now());
101 let connected = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::Connected));
102 assert!(client.events().any(connected));
103
104 assert_eq!(client.state(), Http3State::Connected);
105
106 // Exchange H3 settings
107 let out = server.process(out.dgram(), now());
108 let out = client.process(out.dgram(), now());
109 let out = server.process(out.dgram(), now());
110 let out = client.process(out.dgram(), now());
111 let out = server.process(out.dgram(), now());
112 drop(client.process(out.dgram(), now()));
113 }
114
115 fn connect(
116 client_params: Http3Parameters,
117 server_params: Http3Parameters,
118 ) -> (Http3Client, Http3Server) {
119 let mut client = default_http3_client(client_params);
120 let mut server = default_http3_server(server_params);
121 connect_with(&mut client, &mut server);
122 (client, server)
123 }
124
125 struct WtTest {
126 client: Http3Client,
127 server: Http3Server,
128 }
129
130 impl WtTest {
131 pub fn new() -> Self {
132 let (client, server) = connect(wt_default_parameters(), wt_default_parameters());
133 Self { client, server }
134 }
135
136 pub fn new_with_params(client_params: Http3Parameters, server_params: Http3Parameters) -> Self {
137 let (client, server) = connect(client_params, server_params);
138 Self { client, server }
139 }
140
141 pub fn new_with(mut client: Http3Client, mut server: Http3Server) -> Self {
142 connect_with(&mut client, &mut server);
143 Self { client, server }
144 }
145 fn negotiate_wt_session(
146 &mut self,
147 accept: &WebTransportSessionAcceptAction,
148 ) -> (StreamId, Option<WebTransportRequest>) {
149 let wt_session_id = self
150 .client
151 .webtransport_create_session(now(), &("https", "something.com", "/"), &[])
152 .unwrap();
153 self.exchange_packets();
154
155 let mut wt_server_session = None;
156 while let Some(event) = self.server.next_event() {
157 match event {
158 Http3ServerEvent::WebTransport(WebTransportServerEvent::NewSession {
159 session,
160 headers,
161 }) => {
162 assert_wt(&headers);
163 session.response(accept).unwrap();
164 wt_server_session = Some(session);
165 }
166 Http3ServerEvent::Data { .. } => {
167 panic!("There should not be any data events!");
168 }
169 _ => {}
170 }
171 }
172
173 self.exchange_packets();
174 (wt_session_id, wt_server_session)
175 }
176
177 fn create_wt_session(&mut self) -> WebTransportRequest {
178 let (wt_session_id, wt_server_session) =
179 self.negotiate_wt_session(&WebTransportSessionAcceptAction::Accept);
180 let wt_session_negotiated_event = |e| {
181 matches!(
182 e,
183 Http3ClientEvent::WebTransport(WebTransportEvent::Session{
184 stream_id,
185 status,
186 headers,
187 }) if (
188 stream_id == wt_session_id &&
189 status == 200 &&
190 headers.contains_header(":status", "200")
191 )
192 )
193 };
194 assert!(self.client.events().any(wt_session_negotiated_event));
195
196 let wt_server_session = wt_server_session.unwrap();
197 assert_eq!(wt_session_id, wt_server_session.stream_id());
198 wt_server_session
199 }
200
201 fn exchange_packets(&mut self) {
202 const RTT: Duration = Duration::from_millis(10);
203 let mut out = None;
204 let mut now = now();
205 loop {
206 now += RTT / 2;
207 out = self.client.process(out, now).dgram();
208 let client_none = out.is_none();
209 now += RTT / 2;
210 out = self.server.process(out, now).dgram();
211 if client_none && out.is_none() {
212 break;
213 }
214 }
215 }
216
217 pub fn cancel_session_client(&mut self, wt_stream_id: StreamId) {
218 self.client
219 .cancel_fetch(wt_stream_id, Error::HttpNoError.code())
220 .unwrap();
221 self.exchange_packets();
222 }
223
224 fn session_closed_client(
225 e: &Http3ClientEvent,
226 id: StreamId,
227 expected_reason: &SessionCloseReason,
228 expected_headers: Option<&Vec<Header>>,
229 ) -> bool {
230 if let Http3ClientEvent::WebTransport(WebTransportEvent::SessionClosed {
231 stream_id,
232 reason,
233 headers,
234 }) = e
235 {
236 *stream_id == id && reason == expected_reason && headers.as_ref() == expected_headers
237 } else {
238 false
239 }
240 }
241
242 pub fn check_session_closed_event_client(
243 &mut self,
244 wt_session_id: StreamId,
245 expected_reason: &SessionCloseReason,
246 expected_headers: Option<&Vec<Header>>,
247 ) {
248 let mut event_found = false;
249
250 while let Some(event) = self.client.next_event() {
251 event_found = Self::session_closed_client(
252 &event,
253 wt_session_id,
254 expected_reason,
255 expected_headers,
256 );
257 if event_found {
258 break;
259 }
260 }
261 assert!(event_found);
262 }
263
264 pub fn cancel_session_server(&mut self, wt_session: &WebTransportRequest) {
265 wt_session.cancel_fetch(Error::HttpNoError.code()).unwrap();
266 self.exchange_packets();
267 }
268
269 fn session_closed_server(
270 e: &Http3ServerEvent,
271 id: StreamId,
272 expected_reason: &SessionCloseReason,
273 ) -> bool {
274 if let Http3ServerEvent::WebTransport(WebTransportServerEvent::SessionClosed {
275 session,
276 reason,
277 headers,
278 }) = e
279 {
280 session.stream_id() == id && reason == expected_reason && headers.is_none()
281 } else {
282 false
283 }
284 }
285
286 pub fn check_session_closed_event_server(
287 &self,
288 wt_session: &WebTransportRequest,
289 expected_reeason: &SessionCloseReason,
290 ) {
291 let event = self.server.next_event().unwrap();
292 assert!(Self::session_closed_server(
293 &event,
294 wt_session.stream_id(),
295 expected_reeason
296 ));
297 }
298
299 fn create_wt_stream_client(
300 &mut self,
301 wt_session_id: StreamId,
302 stream_type: StreamType,
303 ) -> StreamId {
304 self.client
305 .webtransport_create_stream(wt_session_id, stream_type)
306 .unwrap()
307 }
308
309 fn send_data_client(&mut self, wt_stream_id: StreamId, data: &[u8]) {
310 assert_eq!(
311 self.client.send_data(wt_stream_id, data).unwrap(),
312 data.len()
313 );
314 self.exchange_packets();
315 }
316
317 fn send_stream_stats(&mut self, wt_stream_id: StreamId) -> Result<SendStreamStats, Error> {
318 self.client.webtransport_send_stream_stats(wt_stream_id)
319 }
320
321 fn recv_stream_stats(&mut self, wt_stream_id: StreamId) -> Result<RecvStreamStats, Error> {
322 self.client.webtransport_recv_stream_stats(wt_stream_id)
323 }
324
325 fn receive_data_client(
326 &mut self,
327 expected_stream_id: StreamId,
328 new_stream: bool,
329 expected_data: &[u8],
330 expected_fin: bool,
331 ) {
332 let mut new_stream_received = false;
333 let mut data_received = false;
334 while let Some(event) = self.client.next_event() {
335 match event {
336 Http3ClientEvent::WebTransport(WebTransportEvent::NewStream {
337 stream_id, ..
338 }) => {
339 assert_eq!(stream_id, expected_stream_id);
340 new_stream_received = true;
341 }
342 Http3ClientEvent::DataReadable { stream_id } => {
343 assert_eq!(stream_id, expected_stream_id);
344 let mut buf = [0; 100];
345 let (amount, fin) = self.client.read_data(now(), stream_id, &mut buf).unwrap();
346 assert_eq!(fin, expected_fin);
347 assert_eq!(amount, expected_data.len());
348 assert_eq!(&buf[..amount], expected_data);
349 data_received = true;
350 }
351 _ => {}
352 }
353 }
354 assert!(data_received);
355 assert_eq!(new_stream, new_stream_received);
356 }
357
358 fn close_stream_sending_client(&mut self, wt_stream_id: StreamId) {
359 self.client.stream_close_send(wt_stream_id).unwrap();
360 self.exchange_packets();
361 }
362
363 fn reset_stream_client(&mut self, wt_stream_id: StreamId) {
364 self.client
365 .stream_reset_send(wt_stream_id, Error::HttpNoError.code())
366 .unwrap();
367 self.exchange_packets();
368 }
369
370 fn receive_reset_client(&mut self, expected_stream_id: StreamId) {
371 let wt_reset_event = |e| {
372 matches!(
373 e,
374 Http3ClientEvent::Reset {
375 stream_id,
376 error,
377 local
378 } if stream_id == expected_stream_id && error == Error::HttpNoError.code() && !local
379 )
380 };
381 assert!(self.client.events().any(wt_reset_event));
382 }
383
384 fn stream_stop_sending_client(&mut self, stream_id: StreamId) {
385 self.client
386 .stream_stop_sending(stream_id, Error::HttpNoError.code())
387 .unwrap();
388 self.exchange_packets();
389 }
390
391 fn receive_stop_sending_client(&mut self, expected_stream_id: StreamId) {
392 let wt_stop_sending_event = |e| {
393 matches!(
394 e,
395 Http3ClientEvent::StopSending {
396 stream_id,
397 error
398 } if stream_id == expected_stream_id && error == Error::HttpNoError.code()
399 )
400 };
401 assert!(self.client.events().any(wt_stop_sending_event));
402 }
403
404 fn check_events_after_closing_session_client(
405 &mut self,
406 expected_reset_ids: &[StreamId],
407 expected_error_stream_reset: Option<u64>,
408 expected_stop_sending_ids: &[StreamId],
409 expected_error_stream_stop_sending: Option<u64>,
410 expected_local: bool,
411 expected_session_close: Option<&(StreamId, SessionCloseReason)>,
412 ) {
413 let mut reset_ids_count = 0;
414 let mut stop_sending_ids_count = 0;
415 let mut close_event = false;
416 while let Some(event) = self.client.next_event() {
417 match event {
418 Http3ClientEvent::Reset {
419 stream_id,
420 error,
421 local,
422 } => {
423 assert!(expected_reset_ids.contains(&stream_id));
424 assert_eq!(expected_error_stream_reset.unwrap(), error);
425 assert_eq!(expected_local, local);
426 reset_ids_count += 1;
427 }
428 Http3ClientEvent::StopSending { stream_id, error } => {
429 assert!(expected_stop_sending_ids.contains(&stream_id));
430 assert_eq!(expected_error_stream_stop_sending.unwrap(), error);
431 stop_sending_ids_count += 1;
432 }
433 Http3ClientEvent::WebTransport(WebTransportEvent::SessionClosed {
434 stream_id,
435 reason,
436 headers,
437 }) => {
438 close_event = true;
439 assert_eq!(stream_id, expected_session_close.as_ref().unwrap().0);
440 assert_eq!(expected_session_close.as_ref().unwrap().1, reason);
441 assert!(headers.is_none());
442 }
443 _ => {}
444 }
445 }
446 assert_eq!(reset_ids_count, expected_reset_ids.len());
447 assert_eq!(stop_sending_ids_count, expected_stop_sending_ids.len());
448 assert_eq!(close_event, expected_session_close.is_some());
449 }
450
451 fn create_wt_stream_server(
452 wt_server_session: &WebTransportRequest,
453 stream_type: StreamType,
454 ) -> Http3OrWebTransportStream {
455 wt_server_session.create_stream(stream_type).unwrap()
456 }
457
458 fn send_data_server(&mut self, wt_stream: &Http3OrWebTransportStream, data: &[u8]) {
459 assert_eq!(wt_stream.send_data(data).unwrap(), data.len());
460 self.exchange_packets();
461 }
462
463 fn receive_data_server(
464 &mut self,
465 stream_id: StreamId,
466 new_stream: bool,
467 expected_data: &[u8],
468 expected_fin: bool,
469 ) -> Http3OrWebTransportStream {
470 self.exchange_packets();
471 let mut new_stream_received = false;
472 let mut data_received = false;
473 let mut wt_stream = None;
474 let mut stream_closed = false;
475 let mut recv_data = Vec::new();
476 while let Some(event) = self.server.next_event() {
477 match event {
478 Http3ServerEvent::WebTransport(WebTransportServerEvent::NewStream(request)) => {
479 assert_eq!(stream_id, request.stream_id());
480 new_stream_received = true;
481 }
482 Http3ServerEvent::Data {
483 mut data,
484 fin,
485 stream,
486 } => {
487 recv_data.append(&mut data);
488 stream_closed = fin;
489 data_received = true;
490 wt_stream = Some(stream);
491 }
492 _ => {}
493 }
494 }
495 assert_eq!(&recv_data[..], expected_data);
496 assert!(data_received);
497 assert_eq!(new_stream, new_stream_received);
498 assert_eq!(stream_closed, expected_fin);
499 wt_stream.unwrap()
500 }
501
502 fn close_stream_sending_server(&mut self, wt_stream: &Http3OrWebTransportStream) {
503 wt_stream.stream_close_send().unwrap();
504 self.exchange_packets();
505 }
506
507 fn reset_stream_server(&mut self, wt_stream: &Http3OrWebTransportStream) {
508 wt_stream
509 .stream_reset_send(Error::HttpNoError.code())
510 .unwrap();
511 self.exchange_packets();
512 }
513
514 fn stream_stop_sending_server(&mut self, wt_stream: &Http3OrWebTransportStream) {
515 wt_stream
516 .stream_stop_sending(Error::HttpNoError.code())
517 .unwrap();
518 self.exchange_packets();
519 }
520
521 fn receive_reset_server(&self, expected_stream_id: StreamId, expected_error: u64) {
522 let stream_reset = |e| {
523 matches!(
524 e,
525 Http3ServerEvent::StreamReset {
526 stream,
527 error
528 } if stream.stream_id() == expected_stream_id && error == expected_error
529 )
530 };
531 assert!(self.server.events().any(stream_reset));
532 }
533
534 fn receive_stop_sending_server(&self, expected_stream_id: StreamId, expected_error: u64) {
535 let stop_sending = |e| {
536 matches!(
537 e,
538 Http3ServerEvent::StreamStopSending {
539 stream,
540 error
541 } if stream.stream_id() == expected_stream_id && error == expected_error
542 )
543 };
544 assert!(self.server.events().any(stop_sending));
545 }
546
547 fn check_events_after_closing_session_server(
548 &self,
549 expected_reset_ids: &[StreamId],
550 expected_error_stream_reset: Option<u64>,
551 expected_stop_sending_ids: &[StreamId],
552 expected_error_stream_stop_sending: Option<u64>,
553 expected_session_close: Option<&(StreamId, SessionCloseReason)>,
554 ) {
555 let mut reset_ids_count = 0;
556 let mut stop_sending_ids_count = 0;
557 let mut close_event = false;
558 while let Some(event) = self.server.next_event() {
559 match event {
560 Http3ServerEvent::StreamReset { stream, error } => {
561 assert!(expected_reset_ids.contains(&stream.stream_id()));
562 assert_eq!(expected_error_stream_reset.unwrap(), error);
563 reset_ids_count += 1;
564 }
565 Http3ServerEvent::StreamStopSending { stream, error } => {
566 assert!(expected_stop_sending_ids.contains(&stream.stream_id()));
567 assert_eq!(expected_error_stream_stop_sending.unwrap(), error);
568 stop_sending_ids_count += 1;
569 }
570 Http3ServerEvent::WebTransport(WebTransportServerEvent::SessionClosed {
571 session,
572 reason,
573 headers,
574 }) => {
575 close_event = true;
576 assert_eq!(
577 session.stream_id(),
578 expected_session_close.as_ref().unwrap().0
579 );
580 assert_eq!(expected_session_close.as_ref().unwrap().1, reason);
581 assert!(headers.is_none());
582 }
583 _ => {}
584 }
585 }
586 assert_eq!(reset_ids_count, expected_reset_ids.len());
587 assert_eq!(stop_sending_ids_count, expected_stop_sending_ids.len());
588 assert_eq!(close_event, expected_session_close.is_some());
589 }
590
591 pub fn session_close_frame_client(&mut self, session_id: StreamId, error: u32, message: &str) {
592 self.client
593 .webtransport_close_session(session_id, error, message)
594 .unwrap();
595 }
596
597 pub fn session_close_frame_server(wt_session: &WebTransportRequest, error: u32, message: &str) {
598 wt_session.close_session(error, message).unwrap();
599 }
600
601 fn max_datagram_size(&self, stream_id: StreamId) -> Result<u64, Error> {
602 self.client.webtransport_max_datagram_size(stream_id)
603 }
604
605 fn send_datagram(&mut self, stream_id: StreamId, buf: &[u8]) -> Result<(), Error> {
606 self.client.webtransport_send_datagram(stream_id, buf, None)
607 }
608
609 fn check_datagram_received_client(
610 &mut self,
611 expected_stream_id: StreamId,
612 expected_dgram: &[u8],
613 ) {
614 let wt_datagram_event = |e| {
615 matches!(
616 e,
617 Http3ClientEvent::WebTransport(WebTransportEvent::Datagram {
618 session_id,
619 datagram
620 }) if session_id == expected_stream_id && datagram == expected_dgram
621 )
622 };
623 assert!(self.client.events().any(wt_datagram_event));
624 }
625
626 fn check_datagram_received_server(
627 &self,
628 expected_session: &WebTransportRequest,
629 expected_dgram: &[u8],
630 ) {
631 let wt_datagram_event = |e| {
632 matches!(
633 e,
634 Http3ServerEvent::WebTransport(WebTransportServerEvent::Datagram {
635 session,
636 datagram
637 }) if session.stream_id() == expected_session.stream_id() && datagram == expected_dgram
638 )
639 };
640 assert!(self.server.events().any(wt_datagram_event));
641 }
642
643 fn check_no_datagram_received_client(&mut self) {
644 let wt_datagram_event = |e| {
645 matches!(
646 e,
647 Http3ClientEvent::WebTransport(WebTransportEvent::Datagram { .. })
648 )
649 };
650 assert!(!self.client.events().any(wt_datagram_event));
651 }
652
653 fn check_no_datagram_received_server(&self) {
654 let wt_datagram_event = |e| {
655 matches!(
656 e,
657 Http3ServerEvent::WebTransport(WebTransportServerEvent::Datagram { .. })
658 )
659 };
660 assert!(!self.server.events().any(wt_datagram_event));
661 }
662 }