Debian Codegraph @

third_party/rust/neqo-http3/src/features/extended_connect/tests/webtransport/sessions.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 neqo_common::{event::Provider as _, header::HeadersExt as _, Encoder};
8 use neqo_transport::StreamType;
9 use test_fixture::now;
10
11 use crate::{
12 features::extended_connect::{
13 tests::webtransport::{
14 assert_wt, default_http3_client, default_http3_server, wt_default_parameters, WtTest,
15 },
16 SessionCloseReason,
17 },
18 frames::WebTransportFrame,
19 Error, Header, Http3ClientEvent, Http3OrWebTransportStream, Http3Server, Http3ServerEvent,
20 Http3State, Priority, WebTransportEvent, WebTransportServerEvent,
21 WebTransportSessionAcceptAction,
22 };
23
24 #[test]
25 fn wt_session() {
26 let mut wt = WtTest::new();
27 drop(wt.create_wt_session());
28 }
29
30 #[test]
31 fn wt_session_reject() {
32 let mut wt = WtTest::new();
33 let headers = vec![Header::new(":status", "404")];
34 let accept_res = WebTransportSessionAcceptAction::Reject(headers.clone());
35 let (wt_session_id, _wt_session) = wt.negotiate_wt_session(&accept_res);
36
37 wt.check_session_closed_event_client(
38 wt_session_id,
39 &SessionCloseReason::Status(404),
40 Some(&headers),
41 );
42 }
43
44 #[test]
45 fn wt_session_close_client() {
46 let mut wt = WtTest::new();
47 let wt_session = wt.create_wt_session();
48
49 wt.cancel_session_client(wt_session.stream_id());
50 wt.check_session_closed_event_server(
51 &wt_session,
52 &SessionCloseReason::Error(Error::HttpNoError.code()),
53 );
54 }
55
56 #[test]
57 fn wt_session_close_server() {
58 let mut wt = WtTest::new();
59 let wt_session = wt.create_wt_session();
60
61 wt.cancel_session_server(&wt_session);
62 wt.check_session_closed_event_client(
63 wt_session.stream_id(),
64 &SessionCloseReason::Error(Error::HttpNoError.code()),
65 None,
66 );
67 }
68
69 #[test]
70 fn wt_session_close_server_close_send() {
71 let mut wt = WtTest::new();
72 let wt_session = wt.create_wt_session();
73
74 wt_session.stream_close_send().unwrap();
75 wt.exchange_packets();
76 wt.check_session_closed_event_client(
77 wt_session.stream_id(),
78 &SessionCloseReason::Clean {
79 error: 0,
80 message: String::new(),
81 },
82 None,
83 );
84 }
85
86 #[test]
87 fn wt_session_close_server_stop_sending() {
88 let mut wt = WtTest::new();
89 let wt_session = wt.create_wt_session();
90
91 wt_session
92 .stream_stop_sending(Error::HttpNoError.code())
93 .unwrap();
94 wt.exchange_packets();
95 wt.check_session_closed_event_client(
96 wt_session.stream_id(),
97 &SessionCloseReason::Error(Error::HttpNoError.code()),
98 None,
99 );
100 }
101
102 #[test]
103 fn wt_session_close_server_reset() {
104 let mut wt = WtTest::new();
105 let wt_session = wt.create_wt_session();
106
107 wt_session
108 .stream_reset_send(Error::HttpNoError.code())
109 .unwrap();
110 wt.exchange_packets();
111 wt.check_session_closed_event_client(
112 wt_session.stream_id(),
113 &SessionCloseReason::Error(Error::HttpNoError.code()),
114 None,
115 );
116 }
117
118 #[test]
119 fn wt_session_response_with_1xx() {
120 let mut wt = WtTest::new();
121
122 let wt_session_id = wt
123 .client
124 .webtransport_create_session(now(), &("https", "something.com", "/"), &[])
125 .unwrap();
126 wt.exchange_packets();
127
128 let mut wt_server_session = None;
129 while let Some(event) = wt.server.next_event() {
130 if let Http3ServerEvent::WebTransport(WebTransportServerEvent::NewSession {
131 session,
132 headers,
133 }) = event
134 {
135 assert_wt(&headers);
136 wt_server_session = Some(session);
137 }
138 }
139
140 let wt_server_session = wt_server_session.unwrap();
141
142 // Send interim response.
143 wt_server_session
144 .send_headers(&[Header::new(":status", "111")])
145 .unwrap();
146 wt_server_session
147 .response(&WebTransportSessionAcceptAction::Accept)
148 .unwrap();
149
150 wt.exchange_packets();
151
152 let wt_session_negotiated_event = |e| {
153 matches!(
154 e,
155 Http3ClientEvent::WebTransport(WebTransportEvent::Session{
156 stream_id,
157 status,
158 headers,
159 }) if (
160 stream_id == wt_session_id &&
161 status == 200 &&
162 headers.contains_header(":status", "200")
163 )
164 )
165 };
166 assert!(wt.client.events().any(wt_session_negotiated_event));
167
168 assert_eq!(wt_session_id, wt_server_session.stream_id());
169 }
170
171 #[test]
172 fn wt_session_response_with_redirect() {
173 let headers = [Header::new(":status", "302"), Header::new("location", "/")].to_vec();
174 let mut wt = WtTest::new();
175
176 let accept_res = WebTransportSessionAcceptAction::Reject(headers.clone());
177
178 let (wt_session_id, _wt_session) = wt.negotiate_wt_session(&accept_res);
179
180 wt.check_session_closed_event_client(
181 wt_session_id,
182 &SessionCloseReason::Status(302),
183 Some(&headers),
184 );
185 }
186
187 #[test]
188 fn wt_session_respone_200_with_fin() {
189 let mut wt = WtTest::new();
190
191 let wt_session_id = wt
192 .client
193 .webtransport_create_session(now(), &("https", "something.com", "/"), &[])
194 .unwrap();
195 wt.exchange_packets();
196 let mut wt_server_session = None;
197 while let Some(event) = wt.server.next_event() {
198 if let Http3ServerEvent::WebTransport(WebTransportServerEvent::NewSession {
199 session,
200 headers,
201 }) = event
202 {
203 assert_wt(&headers);
204 wt_server_session = Some(session);
205 }
206 }
207
208 let wt_server_session = wt_server_session.unwrap();
209 wt_server_session
210 .response(&WebTransportSessionAcceptAction::Accept)
211 .unwrap();
212 wt_server_session.stream_close_send().unwrap();
213
214 wt.exchange_packets();
215
216 let wt_session_close_event = |e| {
217 matches!(
218 e,
219 Http3ClientEvent::WebTransport(WebTransportEvent::SessionClosed{
220 stream_id,
221 reason,
222 headers,
223 ..
224 }) if (
225 stream_id == wt_session_id &&
226 reason == SessionCloseReason::Clean{ error: 0, message: String::new()} &&
227 headers.is_none()
228 )
229 )
230 };
231 assert!(wt.client.events().any(wt_session_close_event));
232
233 assert_eq!(wt_session_id, wt_server_session.stream_id());
234 }
235
236 #[test]
237 fn wt_session_close_frame_client() {
238 const ERROR_NUM: u32 = 23;
239 const ERROR_MESSAGE: &str = "Something went wrong";
240 let mut wt = WtTest::new();
241 let wt_session = wt.create_wt_session();
242
243 wt.session_close_frame_client(wt_session.stream_id(), ERROR_NUM, ERROR_MESSAGE);
244 wt.exchange_packets();
245
246 wt.check_session_closed_event_server(
247 &wt_session,
248 &SessionCloseReason::Clean {
249 error: ERROR_NUM,
250 message: ERROR_MESSAGE.to_string(),
251 },
252 );
253 }
254
255 #[test]
256 fn wt_session_close_frame_server() {
257 const ERROR_NUM: u32 = 23;
258 const ERROR_MESSAGE: &str = "Something went wrong";
259 let mut wt = WtTest::new();
260 let wt_session = wt.create_wt_session();
261
262 WtTest::session_close_frame_server(&wt_session, ERROR_NUM, ERROR_MESSAGE);
263 wt.exchange_packets();
264
265 wt.check_session_closed_event_client(
266 wt_session.stream_id(),
267 &SessionCloseReason::Clean {
268 error: ERROR_NUM,
269 message: ERROR_MESSAGE.to_string(),
270 },
271 None,
272 );
273 }
274
275 #[test]
276 fn wt_unknown_session_frame_client() {
277 const UNKNOWN_FRAME_LEN: usize = 832;
278 const BUF: &[u8] = &[0; 10];
279 const ERROR_NUM: u32 = 23;
280 const ERROR_MESSAGE: &str = "Something went wrong";
281 let mut wt = WtTest::new();
282 let wt_session = wt.create_wt_session();
283
284 // Send an unknown frame.
285 let mut enc = Encoder::with_capacity(UNKNOWN_FRAME_LEN + 4);
286 enc.encode_varint(1028_u64); // Arbitrary type.
287 enc.encode_varint(UNKNOWN_FRAME_LEN as u64);
288 let mut buf: Vec<_> = enc.into();
289 buf.resize(UNKNOWN_FRAME_LEN + buf.len(), 0);
290 wt.client.send_data(wt_session.stream_id(), &buf).unwrap();
291 wt.exchange_packets();
292
293 // The session is still active
294 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
295 wt.send_data_server(&unidi_server, BUF);
296 wt.receive_data_client(unidi_server.stream_id(), true, BUF, false);
297
298 // Now close the session.
299 wt.session_close_frame_client(wt_session.stream_id(), ERROR_NUM, ERROR_MESSAGE);
300 wt.exchange_packets();
301
302 wt.check_events_after_closing_session_client(
303 &[unidi_server.stream_id()],
304 Some(Error::HttpRequestCancelled.code()),
305 &[],
306 None,
307 false,
308 None,
309 );
310 wt.check_events_after_closing_session_server(
311 &[],
312 None,
313 &[unidi_server.stream_id()],
314 Some(Error::HttpRequestCancelled.code()),
315 Some(&(
316 wt_session.stream_id(),
317 SessionCloseReason::Clean {
318 error: ERROR_NUM,
319 message: ERROR_MESSAGE.to_string(),
320 },
321 )),
322 );
323 }
324
325 #[test]
326 fn wt_close_session_frame_broken_client() {
327 let mut wt = WtTest::new();
328 let wt_session = wt.create_wt_session();
329
330 // Send a incorrect CloseSession frame.
331 let mut enc = Encoder::default();
332 WebTransportFrame::CloseSession {
333 error: 5,
334 message: "Hello".to_string(),
335 }
336 .encode(&mut enc);
337 let mut buf: Vec<_> = enc.into();
338 // Corrupt the string.
339 buf[9] = 0xff;
340 wt.client.send_data(wt_session.stream_id(), &buf).unwrap();
341 wt.exchange_packets();
342
343 // check that the webtransport session is closed.
344 wt.check_session_closed_event_client(
345 wt_session.stream_id(),
346 &SessionCloseReason::Error(Error::HttpGeneralProtocolStream.code()),
347 None,
348 );
349 wt.check_session_closed_event_server(
350 &wt_session,
351 &SessionCloseReason::Error(Error::HttpGeneralProtocolStream.code()),
352 );
353
354 // The Http3 session is still working.
355 assert_eq!(wt.client.state(), Http3State::Connected);
356 assert_eq!(wt_session.state(), Http3State::Connected);
357 }
358
359 fn receive_request(server: &Http3Server) -> Option<Http3OrWebTransportStream> {
360 while let Some(event) = server.next_event() {
361 if let Http3ServerEvent::Headers { stream, .. } = event {
362 return Some(stream);
363 }
364 }
365 None
366 }
367
368 #[test]
369 #[ignore = "Is panicking at wt.create_wt_stream_client; see issue #1386"]
370 fn wt_close_session_cannot_be_sent_at_once() {
371 const BUF: &[u8] = &[0; 443];
372 const ERROR_NUM: u32 = 23;
373 const ERROR_MESSAGE: &str = "Something went wrong";
374
375 let client = default_http3_client(wt_default_parameters());
376 let server = default_http3_server(wt_default_parameters());
377 let mut wt = WtTest::new_with(client, server);
378
379 let wt_session = wt.create_wt_session();
380
381 // Fill the flow control window using an unrelated http stream.
382 let req_id = wt
383 .client
384 .fetch(
385 now(),
386 "GET",
387 &("https", "something.com", "/"),
388 &[],
389 Priority::default(),
390 )
391 .unwrap();
392 assert_eq!(req_id, 4);
393 wt.exchange_packets();
394 let req = receive_request(&wt.server).unwrap();
395 req.send_headers(&[
396 Header::new(":status", "200"),
397 Header::new("content-length", BUF.len().to_string()),
398 ])
399 .unwrap();
400 req.send_data(BUF).unwrap();
401
402 // Now close the session.
403 WtTest::session_close_frame_server(&wt_session, ERROR_NUM, ERROR_MESSAGE);
404 // server cannot create new streams.
405 assert_eq!(
406 wt_session.create_stream(StreamType::UniDi),
407 Err(Error::InvalidStreamId)
408 );
409
410 let out = wt.server.process_output(now());
411 let out = wt.client.process(out.dgram(), now());
412
413 // Client has not received the full CloseSession frame and it can create more streams.
414 let unidi_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
415
416 let out = wt.server.process(out.dgram(), now());
417 let out = wt.client.process(out.dgram(), now());
418 let out = wt.server.process(out.dgram(), now());
419 let out = wt.client.process(out.dgram(), now());
420 let out = wt.server.process(out.dgram(), now());
421 let _out = wt.client.process(out.dgram(), now());
422
423 wt.check_events_after_closing_session_client(
424 &[],
425 None,
426 &[unidi_client],
427 Some(Error::HttpRequestCancelled.code()),
428 false,
429 Some(&(
430 wt_session.stream_id(),
431 SessionCloseReason::Clean {
432 error: ERROR_NUM,
433 message: ERROR_MESSAGE.to_string(),
434 },
435 )),
436 );
437 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
438 }