Debian Codegraph @

third_party/rust/neqo-http3/tests/webtransport.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 #![cfg(test)]
8
9 use std::{cell::RefCell, rc::Rc};
10
11 use neqo_common::{event::Provider as _, header::HeadersExt as _};
12 use neqo_crypto::AuthenticationStatus;
13 use neqo_http3::{
14 Http3Client, Http3ClientEvent, Http3OrWebTransportStream, Http3Parameters, Http3Server,
15 Http3ServerEvent, Http3State, WebTransportEvent, WebTransportRequest, WebTransportServerEvent,
16 WebTransportSessionAcceptAction,
17 };
18 use neqo_transport::{ConnectionParameters, StreamId, StreamType};
19 use test_fixture::{
20 anti_replay, fixture_init, now, CountingConnectionIdGenerator, DEFAULT_ADDR, DEFAULT_ALPN_H3,
21 DEFAULT_KEYS, DEFAULT_SERVER_NAME,
22 };
23
24 fn connect() -> (Http3Client, Http3Server) {
25 fixture_init();
26 let mut client = Http3Client::new(
27 DEFAULT_SERVER_NAME,
28 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
29 DEFAULT_ADDR,
30 DEFAULT_ADDR,
31 Http3Parameters::default().webtransport(true),
32 now(),
33 )
34 .expect("create a default client");
35 let mut server = Http3Server::new(
36 now(),
37 DEFAULT_KEYS,
38 DEFAULT_ALPN_H3,
39 anti_replay(),
40 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
41 Http3Parameters::default().webtransport(true),
42 None,
43 )
44 .expect("create a server");
45 assert_eq!(client.state(), Http3State::Initializing);
46 let out = client.process_output(now());
47 let out2 = client.process_output(now());
48 assert_eq!(client.state(), Http3State::Initializing);
49
50 _ = server.process(out.dgram(), now());
51 let out = server.process(out2.dgram(), now());
52 let out = client.process(out.dgram(), now());
53 let out = server.process(out.dgram(), now());
54 let out = client.process(out.dgram(), now());
55 let out = server.process(out.dgram(), now());
56 assert!(out.as_dgram_ref().is_none());
57
58 let authentication_needed = |e| matches!(e, Http3ClientEvent::AuthenticationNeeded);
59 assert!(client.events().any(authentication_needed));
60 client.authenticated(AuthenticationStatus::Ok, now());
61
62 let mut out = client.process(out.dgram(), now()).dgram();
63 let connected = |e| matches!(e, Http3ClientEvent::StateChange(Http3State::Connected));
64 assert!(client.events().any(connected));
65
66 assert_eq!(client.state(), Http3State::Connected);
67
68 // Exchange H3 settings
69 loop {
70 out = server.process(out, now()).dgram();
71 let dgram_present = out.is_some();
72 out = client.process(out, now()).dgram();
73 if out.is_none() && !dgram_present {
74 break;
75 }
76 }
77 (client, server)
78 }
79
80 fn exchange_packets(client: &mut Http3Client, server: &mut Http3Server) {
81 let mut out = None;
82 loop {
83 out = client.process(out, now()).dgram();
84 out = server.process(out, now()).dgram();
85 if out.is_none() {
86 break;
87 }
88 }
89 }
90
91 fn create_wt_session(client: &mut Http3Client, server: &mut Http3Server) -> WebTransportRequest {
92 let wt_session_id = client
93 .webtransport_create_session(now(), &("https", "something.com", "/"), &[])
94 .unwrap();
95 exchange_packets(client, server);
96
97 let mut wt_server_session = None;
98 while let Some(event) = server.next_event() {
99 match event {
100 Http3ServerEvent::WebTransport(WebTransportServerEvent::NewSession {
101 session,
102 headers,
103 }) => {
104 assert!(
105 headers.contains_header(":method", "CONNECT")
106 && headers.contains_header(":protocol", "webtransport")
107 );
108 session
109 .response(&WebTransportSessionAcceptAction::Accept)
110 .unwrap();
111 wt_server_session = Some(session);
112 }
113 Http3ServerEvent::Data { .. } => {
114 panic!("There should not be any data events!");
115 }
116 _ => {}
117 }
118 }
119
120 exchange_packets(client, server);
121
122 let wt_session_negotiated_event = |e| {
123 matches!(
124 e,
125 Http3ClientEvent::WebTransport(WebTransportEvent::Session{
126 stream_id,
127 status,
128 headers,
129 }) if (
130 stream_id == wt_session_id &&
131 status == 200 &&
132 headers.contains_header(":status", "200")
133 )
134 )
135 };
136 assert!(client.events().any(wt_session_negotiated_event));
137
138 let wt_server_session = wt_server_session.unwrap();
139 assert_eq!(wt_session_id, wt_server_session.stream_id());
140 wt_server_session
141 }
142
143 fn send_data_client(
144 client: &mut Http3Client,
145 server: &mut Http3Server,
146 wt_stream_id: StreamId,
147 data: &[u8],
148 ) {
149 assert_eq!(client.send_data(wt_stream_id, data).unwrap(), data.len());
150 exchange_packets(client, server);
151 }
152
153 fn send_data_server(
154 client: &mut Http3Client,
155 server: &mut Http3Server,
156 wt_stream: &Http3OrWebTransportStream,
157 data: &[u8],
158 ) {
159 assert_eq!(wt_stream.send_data(data).unwrap(), data.len());
160 exchange_packets(client, server);
161 }
162
163 fn receive_data_client(
164 client: &mut Http3Client,
165 expected_stream_id: StreamId,
166 new_stream: bool,
167 expected_data: &[u8],
168 expected_fin: bool,
169 ) {
170 let mut new_stream_received = false;
171 let mut data_received = false;
172 while let Some(event) = client.next_event() {
173 match event {
174 Http3ClientEvent::WebTransport(WebTransportEvent::NewStream { stream_id, .. }) => {
175 assert_eq!(stream_id, expected_stream_id);
176 new_stream_received = true;
177 }
178 Http3ClientEvent::DataReadable { stream_id } => {
179 assert_eq!(stream_id, expected_stream_id);
180 let mut buf = [0; 100];
181 let (amount, fin) = client.read_data(now(), stream_id, &mut buf).unwrap();
182 assert_eq!(fin, expected_fin);
183 assert_eq!(amount, expected_data.len());
184 assert_eq!(&buf[..amount], expected_data);
185 data_received = true;
186 }
187 _ => {}
188 }
189 }
190 assert!(data_received);
191 assert_eq!(new_stream, new_stream_received);
192 }
193
194 fn receive_data_server(
195 client: &mut Http3Client,
196 server: &mut Http3Server,
197 stream_id: StreamId,
198 new_stream: bool,
199 expected_data: &[u8],
200 expected_fin: bool,
201 ) -> Http3OrWebTransportStream {
202 exchange_packets(client, server);
203 let mut new_stream_received = false;
204 let mut data_received = false;
205 let mut wt_stream = None;
206 let mut stream_closed = false;
207 let mut recv_data = Vec::new();
208 while let Some(event) = server.next_event() {
209 match event {
210 Http3ServerEvent::WebTransport(WebTransportServerEvent::NewStream(request)) => {
211 assert_eq!(stream_id, request.stream_id());
212 new_stream_received = true;
213 }
214 Http3ServerEvent::Data {
215 mut data,
216 fin,
217 stream,
218 } => {
219 recv_data.append(&mut data);
220 stream_closed = fin;
221 data_received = true;
222 wt_stream = Some(stream);
223 }
224 _ => {}
225 }
226 }
227 assert_eq!(&recv_data[..], expected_data);
228 assert!(data_received);
229 assert_eq!(new_stream, new_stream_received);
230 assert_eq!(stream_closed, expected_fin);
231 wt_stream.unwrap()
232 }
233
234 #[test]
235 fn wt_keepalive() {
236 let (mut client, mut server) = connect();
237 let _wt_session = create_wt_session(&mut client, &mut server);
238 let idle_timeout = ConnectionParameters::default().get_idle_timeout();
239 // Expect client and server to send PING after half of the idle timeout in order to keep
240 // connection alive.
241 assert_eq!(client.process_output(now()).callback(), idle_timeout / 2);
242 assert_eq!(server.process_output(now()).callback(), idle_timeout / 2);
243 }
244
245 #[test]
246 fn wt_client_stream_uni() {
247 const BUF_CLIENT: &[u8] = &[0; 10];
248
249 let (mut client, mut server) = connect();
250 let wt_session = create_wt_session(&mut client, &mut server);
251 let wt_stream = client
252 .webtransport_create_stream(wt_session.stream_id(), StreamType::UniDi)
253 .unwrap();
254 send_data_client(&mut client, &mut server, wt_stream, BUF_CLIENT);
255 exchange_packets(&mut client, &mut server);
256 receive_data_server(&mut client, &mut server, wt_stream, true, BUF_CLIENT, false);
257 }
258
259 #[test]
260 fn wt_client_stream_bidi() {
261 const BUF_CLIENT: &[u8] = &[0; 10];
262 const BUF_SERVER: &[u8] = &[1; 20];
263
264 let (mut client, mut server) = connect();
265 let wt_session = create_wt_session(&mut client, &mut server);
266 let wt_client_stream = client
267 .webtransport_create_stream(wt_session.stream_id(), StreamType::BiDi)
268 .unwrap();
269 send_data_client(&mut client, &mut server, wt_client_stream, BUF_CLIENT);
270 let wt_server_stream = receive_data_server(
271 &mut client,
272 &mut server,
273 wt_client_stream,
274 true,
275 BUF_CLIENT,
276 false,
277 );
278 send_data_server(&mut client, &mut server, &wt_server_stream, BUF_SERVER);
279 receive_data_client(&mut client, wt_client_stream, false, BUF_SERVER, false);
280 }
281
282 #[test]
283 fn wt_server_stream_uni() {
284 const BUF_SERVER: &[u8] = &[2; 30];
285
286 let (mut client, mut server) = connect();
287 let wt_session = create_wt_session(&mut client, &mut server);
288 let wt_server_stream = wt_session.create_stream(StreamType::UniDi).unwrap();
289 send_data_server(&mut client, &mut server, &wt_server_stream, BUF_SERVER);
290 receive_data_client(
291 &mut client,
292 wt_server_stream.stream_id(),
293 true,
294 BUF_SERVER,
295 false,
296 );
297 }
298
299 #[test]
300 fn wt_server_stream_bidi() {
301 const BUF_CLIENT: &[u8] = &[0; 10];
302 const BUF_SERVER: &[u8] = &[1; 20];
303
304 let (mut client, mut server) = connect();
305 let wt_session = create_wt_session(&mut client, &mut server);
306 let wt_server_stream = wt_session.create_stream(StreamType::BiDi).unwrap();
307 send_data_server(&mut client, &mut server, &wt_server_stream, BUF_SERVER);
308 receive_data_client(
309 &mut client,
310 wt_server_stream.stream_id(),
311 true,
312 BUF_SERVER,
313 false,
314 );
315 send_data_client(
316 &mut client,
317 &mut server,
318 wt_server_stream.stream_id(),
319 BUF_CLIENT,
320 );
321 assert_eq!(
322 receive_data_server(
323 &mut client,
324 &mut server,
325 wt_server_stream.stream_id(),
326 false,
327 BUF_CLIENT,
328 false
329 )
330 .stream_id(),
331 wt_server_stream.stream_id()
332 );
333 }