Debian Codegraph @

third_party/rust/neqo-http3/src/features/extended_connect/tests/webtransport/negotiation.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::time::Duration;
8
9 use neqo_common::{event::Provider as _, Encoder};
10 use neqo_crypto::AuthenticationStatus;
11 use neqo_transport::{CloseReason, Connection, StreamType};
12 use test_fixture::{default_server_h3, now};
13
14 use super::{connect, default_http3_client, default_http3_server, exchange_packets};
15 use crate::{
16 settings::{HSetting, HSettingType, HSettings},
17 Error, HFrame, Http3Client, Http3ClientEvent, Http3Parameters, Http3Server, Http3State,
18 WebTransportEvent,
19 };
20
21 fn check_wt_event(client: &mut Http3Client, wt_enable_client: bool, wt_enable_server: bool) {
22 let wt_event = client.events().find_map(|e| {
23 if let Http3ClientEvent::WebTransport(WebTransportEvent::Negotiated(neg)) = e {
24 Some(neg)
25 } else {
26 None
27 }
28 });
29
30 assert_eq!(wt_event.is_some(), wt_enable_client);
31 if let Some(wt) = wt_event {
32 assert_eq!(wt, wt_enable_client && wt_enable_server);
33 }
34 }
35
36 fn connect_wt(wt_enabled_client: bool, wt_enabled_server: bool) -> (Http3Client, Http3Server) {
37 connect(
38 Http3Parameters::default().webtransport(wt_enabled_client),
39 Http3Parameters::default().webtransport(wt_enabled_server),
40 )
41 }
42
43 #[test]
44 fn negotiate_wt() {
45 let (mut client, _server) = connect_wt(true, true);
46 assert!(client.webtransport_enabled());
47 check_wt_event(&mut client, true, true);
48
49 let (mut client, _server) = connect_wt(true, false);
50 assert!(!client.webtransport_enabled());
51 check_wt_event(&mut client, true, false);
52
53 let (mut client, _server) = connect_wt(false, true);
54 assert!(!client.webtransport_enabled());
55 check_wt_event(&mut client, false, true);
56
57 let (mut client, _server) = connect_wt(false, false);
58 assert!(!client.webtransport_enabled());
59 check_wt_event(&mut client, false, false);
60 }
61
62 #[derive(PartialEq, Eq)]
63 enum ClientState {
64 ClientEnabled,
65 ClientDisabled,
66 }
67
68 #[derive(PartialEq, Eq)]
69 enum ServerState {
70 ServerEnabled,
71 ServerDisabled,
72 }
73
74 fn zero_rtt(
75 client_state: &ClientState,
76 server_state: &ServerState,
77 client_resumed_state: &ClientState,
78 server_resumed_state: &ServerState,
79 ) {
80 let client_org = ClientState::ClientEnabled.eq(client_state);
81 let server_org = ServerState::ServerEnabled.eq(server_state);
82 let client_resumed = ClientState::ClientEnabled.eq(client_resumed_state);
83 let server_resumed = ServerState::ServerEnabled.eq(server_resumed_state);
84
85 let (mut client, mut server) = connect_wt(client_org, server_org);
86 assert_eq!(client.webtransport_enabled(), client_org && server_org);
87
88 // exchange token
89 let out = server.process_output(now());
90 // We do not have a token so we need to wait for a resumption token timer to trigger.
91 drop(client.process(out.dgram(), now() + Duration::from_millis(250)));
92 assert_eq!(client.state(), Http3State::Connected);
93 let token = client
94 .events()
95 .find_map(|e| {
96 if let Http3ClientEvent::ResumptionToken(token) = e {
97 Some(token)
98 } else {
99 None
100 }
101 })
102 .unwrap();
103
104 let mut client = default_http3_client(Http3Parameters::default().webtransport(client_resumed));
105 let mut server = default_http3_server(Http3Parameters::default().webtransport(server_resumed));
106 client
107 .enable_resumption(now(), &token)
108 .expect("Set resumption token");
109 assert_eq!(client.state(), Http3State::ZeroRtt);
110
111 exchange_packets(&mut client, &mut server);
112
113 assert_eq!(&client.state(), &Http3State::Connected);
114 assert_eq!(
115 client.webtransport_enabled(),
116 client_resumed && server_resumed
117 );
118
119 // The only case we should not do 0-RTT is when webtransport was enabled
120 // originally and is disabled afterwards.
121 let early_data_accepted = !server_org || server_resumed;
122 assert_eq!(
123 client.tls_info().unwrap().early_data_accepted(),
124 early_data_accepted
125 );
126
127 check_wt_event(&mut client, client_resumed, server_resumed);
128 }
129
130 #[test]
131 fn zero_rtt_wt_settings() {
132 zero_rtt(
133 &ClientState::ClientEnabled,
134 &ServerState::ServerEnabled,
135 &ClientState::ClientEnabled,
136 &ServerState::ServerEnabled,
137 );
138 zero_rtt(
139 &ClientState::ClientEnabled,
140 &ServerState::ServerEnabled,
141 &ClientState::ClientEnabled,
142 &ServerState::ServerDisabled,
143 );
144 zero_rtt(
145 &ClientState::ClientEnabled,
146 &ServerState::ServerEnabled,
147 &ClientState::ClientDisabled,
148 &ServerState::ServerEnabled,
149 );
150 zero_rtt(
151 &ClientState::ClientEnabled,
152 &ServerState::ServerEnabled,
153 &ClientState::ClientDisabled,
154 &ServerState::ServerDisabled,
155 );
156
157 zero_rtt(
158 &ClientState::ClientEnabled,
159 &ServerState::ServerDisabled,
160 &ClientState::ClientEnabled,
161 &ServerState::ServerDisabled,
162 );
163 zero_rtt(
164 &ClientState::ClientEnabled,
165 &ServerState::ServerDisabled,
166 &ClientState::ClientEnabled,
167 &ServerState::ServerEnabled,
168 );
169 zero_rtt(
170 &ClientState::ClientEnabled,
171 &ServerState::ServerDisabled,
172 &ClientState::ClientDisabled,
173 &ServerState::ServerDisabled,
174 );
175 zero_rtt(
176 &ClientState::ClientEnabled,
177 &ServerState::ServerDisabled,
178 &ClientState::ClientDisabled,
179 &ServerState::ServerEnabled,
180 );
181
182 zero_rtt(
183 &ClientState::ClientDisabled,
184 &ServerState::ServerDisabled,
185 &ClientState::ClientDisabled,
186 &ServerState::ServerDisabled,
187 );
188 zero_rtt(
189 &ClientState::ClientDisabled,
190 &ServerState::ServerDisabled,
191 &ClientState::ClientDisabled,
192 &ServerState::ServerEnabled,
193 );
194 zero_rtt(
195 &ClientState::ClientDisabled,
196 &ServerState::ServerDisabled,
197 &ClientState::ClientEnabled,
198 &ServerState::ServerDisabled,
199 );
200 zero_rtt(
201 &ClientState::ClientDisabled,
202 &ServerState::ServerDisabled,
203 &ClientState::ClientEnabled,
204 &ServerState::ServerEnabled,
205 );
206
207 zero_rtt(
208 &ClientState::ClientDisabled,
209 &ServerState::ServerEnabled,
210 &ClientState::ClientDisabled,
211 &ServerState::ServerEnabled,
212 );
213 zero_rtt(
214 &ClientState::ClientDisabled,
215 &ServerState::ServerEnabled,
216 &ClientState::ClientDisabled,
217 &ServerState::ServerDisabled,
218 );
219 zero_rtt(
220 &ClientState::ClientDisabled,
221 &ServerState::ServerEnabled,
222 &ClientState::ClientEnabled,
223 &ServerState::ServerDisabled,
224 );
225 zero_rtt(
226 &ClientState::ClientDisabled,
227 &ServerState::ServerEnabled,
228 &ClientState::ClientEnabled,
229 &ServerState::ServerEnabled,
230 );
231 }
232
233 fn exchange_packets2(client: &mut Http3Client, server: &mut Connection) {
234 let mut out = None;
235 loop {
236 out = client.process(out, now()).dgram();
237 out = server.process(out, now()).dgram();
238 if out.is_none() {
239 break;
240 }
241 }
242 }
243
244 #[test]
245 fn wrong_setting_value() {
246 const CONTROL_STREAM_TYPE: &[u8] = &[0x0];
247 let mut client = default_http3_client(Http3Parameters::default());
248 let mut server = default_server_h3();
249
250 exchange_packets2(&mut client, &mut server);
251 client.authenticated(AuthenticationStatus::Ok, now());
252 exchange_packets2(&mut client, &mut server);
253
254 let control = server.stream_create(StreamType::UniDi).unwrap();
255 server.stream_send(control, CONTROL_STREAM_TYPE).unwrap();
256 // Encode a settings frame and send it.
257 let mut enc = Encoder::default();
258 let settings = HFrame::Settings {
259 settings: HSettings::new(&[HSetting::new(HSettingType::EnableWebTransport, 2)]),
260 };
261 settings.encode(&mut enc);
262 assert_eq!(
263 server.stream_send(control, enc.as_ref()).unwrap(),
264 enc.as_ref().len()
265 );
266
267 exchange_packets2(&mut client, &mut server);
268 match client.state() {
269 Http3State::Closing(err) | Http3State::Closed(err) => {
270 assert_eq!(err, CloseReason::Application(Error::HttpSettings.code()));
271 }
272 _ => panic!("Wrong state {:?}", client.state()),
273 }
274 }