Debian Codegraph @

third_party/rust/neqo-http3/src/client_events.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::{cell::RefCell, collections::VecDeque, rc::Rc};
8
9 use neqo_common::{event::Provider as EventProvider, Header};
10 use neqo_crypto::ResumptionToken;
11 use neqo_transport::{AppError, StreamId, StreamType};
12
13 use crate::{
14 connection::Http3State,
15 features::extended_connect::{ExtendedConnectEvents, ExtendedConnectType, SessionCloseReason},
16 settings::HSettingType,
17 CloseType, Error, Http3StreamInfo, HttpRecvStreamEvents, PushId, RecvStreamEvents, Res,
18 SendStreamEvents,
19 };
20
21 #[derive(Debug, PartialEq, Eq, Clone)]
22 pub enum WebTransportEvent {
23 Negotiated(bool),
24 Session {
25 stream_id: StreamId,
26 status: u16,
27 headers: Vec<Header>,
28 },
29 SessionClosed {
30 stream_id: StreamId,
31 reason: SessionCloseReason,
32 headers: Option<Vec<Header>>,
33 },
34 NewStream {
35 stream_id: StreamId,
36 session_id: StreamId,
37 },
38 Datagram {
39 session_id: StreamId,
40 datagram: Vec<u8>,
41 },
42 }
43
44 #[derive(Debug, PartialEq, Eq, Clone)]
45 pub enum Http3ClientEvent {
46 /// Response headers are received.
47 HeaderReady {
48 stream_id: StreamId,
49 headers: Vec<Header>,
50 interim: bool,
51 fin: bool,
52 },
53 /// A stream can accept new data.
54 DataWritable { stream_id: StreamId },
55 /// New bytes available for reading.
56 DataReadable { stream_id: StreamId },
57 /// Peer reset the stream or there was an parsing error.
58 Reset {
59 stream_id: StreamId,
60 error: AppError,
61 local: bool,
62 },
63 /// Peer has sent a `STOP_SENDING`.
64 StopSending {
65 stream_id: StreamId,
66 error: AppError,
67 },
68 /// A new push promise.
69 PushPromise {
70 push_id: PushId,
71 request_stream_id: StreamId,
72 headers: Vec<Header>,
73 },
74 /// A push response headers are ready.
75 PushHeaderReady {
76 push_id: PushId,
77 headers: Vec<Header>,
78 interim: bool,
79 fin: bool,
80 },
81 /// New bytes are available on a push stream for reading.
82 PushDataReadable { push_id: PushId },
83 /// A push has been canceled.
84 PushCanceled { push_id: PushId },
85 /// A push stream was been reset due to a `HttpGeneralProtocol` error.
86 /// Most common case are malformed response headers.
87 PushReset { push_id: PushId, error: AppError },
88 /// New stream can be created
89 RequestsCreatable,
90 /// Cert authentication needed
91 AuthenticationNeeded,
92 /// Encrypted client hello fallback occurred. The certificate for the
93 /// name `public_name` needs to be authenticated in order to get
94 /// an updated ECH configuration.
95 EchFallbackAuthenticationNeeded { public_name: String },
96 /// A new resumption token.
97 ResumptionToken(ResumptionToken),
98 /// Zero Rtt has been rejected.
99 ZeroRttRejected,
100 /// Client has received a GOAWAY frame
101 GoawayReceived,
102 /// Connection state change.
103 StateChange(Http3State),
104 /// `WebTransport` events
105 WebTransport(WebTransportEvent),
106 }
107
108 #[derive(Debug, Default, Clone)]
109 pub struct Http3ClientEvents {
110 events: Rc<RefCell<VecDeque<Http3ClientEvent>>>,
111 }
112
113 impl RecvStreamEvents for Http3ClientEvents {
114 /// Add a new `DataReadable` event
115 fn data_readable(&self, stream_info: Http3StreamInfo) {
116 self.insert(Http3ClientEvent::DataReadable {
117 stream_id: stream_info.stream_id(),
118 });
119 }
120
121 /// Add a new `Reset` event.
122 fn recv_closed(&self, stream_info: Http3StreamInfo, close_type: CloseType) {
123 let stream_id = stream_info.stream_id();
124 let (local, error) = match close_type {
125 CloseType::ResetApp(_) => {
126 self.remove_recv_stream_events(stream_id);
127 return;
128 }
129 CloseType::Done => return,
130 CloseType::ResetRemote(e) => {
131 self.remove_recv_stream_events(stream_id);
132 (false, e)
133 }
134 CloseType::LocalError(e) => {
135 self.remove_recv_stream_events(stream_id);
136 (true, e)
137 }
138 };
139
140 self.insert(Http3ClientEvent::Reset {
141 stream_id,
142 error,
143 local,
144 });
145 }
146 }
147
148 impl HttpRecvStreamEvents for Http3ClientEvents {
149 /// Add a new `HeaderReady` event.
150 fn header_ready(
151 &self,
152 stream_info: Http3StreamInfo,
153 headers: Vec<Header>,
154 interim: bool,
155 fin: bool,
156 ) {
157 self.insert(Http3ClientEvent::HeaderReady {
158 stream_id: stream_info.stream_id(),
159 headers,
160 interim,
161 fin,
162 });
163 }
164 }
165
166 impl SendStreamEvents for Http3ClientEvents {
167 /// Add a new `DataWritable` event.
168 fn data_writable(&self, stream_info: Http3StreamInfo) {
169 self.insert(Http3ClientEvent::DataWritable {
170 stream_id: stream_info.stream_id(),
171 });
172 }
173
174 fn send_closed(&self, stream_info: Http3StreamInfo, close_type: CloseType) {
175 let stream_id = stream_info.stream_id();
176 self.remove_send_stream_events(stream_id);
177 if let CloseType::ResetRemote(error) = close_type {
178 self.insert(Http3ClientEvent::StopSending { stream_id, error });
179 }
180 }
181 }
182
183 impl ExtendedConnectEvents for Http3ClientEvents {
184 fn session_start(
185 &self,
186 connect_type: ExtendedConnectType,
187 stream_id: StreamId,
188 status: u16,
189 headers: Vec<Header>,
190 ) {
191 if connect_type == ExtendedConnectType::WebTransport {
192 self.insert(Http3ClientEvent::WebTransport(WebTransportEvent::Session {
193 stream_id,
194 status,
195 headers,
196 }));
197 } else {
198 unreachable!("There is only ExtendedConnectType::WebTransport");
199 }
200 }
201
202 fn session_end(
203 &self,
204 connect_type: ExtendedConnectType,
205 stream_id: StreamId,
206 reason: SessionCloseReason,
207 headers: Option<Vec<Header>>,
208 ) {
209 if connect_type == ExtendedConnectType::WebTransport {
210 self.insert(Http3ClientEvent::WebTransport(
211 WebTransportEvent::SessionClosed {
212 stream_id,
213 reason,
214 headers,
215 },
216 ));
217 } else {
218 unreachable!("There are no other types");
219 }
220 }
221
222 fn extended_connect_new_stream(&self, stream_info: Http3StreamInfo) -> Res<()> {
223 self.insert(Http3ClientEvent::WebTransport(
224 WebTransportEvent::NewStream {
225 stream_id: stream_info.stream_id(),
226 session_id: stream_info.session_id().ok_or(Error::Internal)?,
227 },
228 ));
229 Ok(())
230 }
231
232 fn new_datagram(&self, session_id: StreamId, datagram: Vec<u8>) {
233 self.insert(Http3ClientEvent::WebTransport(
234 WebTransportEvent::Datagram {
235 session_id,
236 datagram,
237 },
238 ));
239 }
240 }
241
242 impl Http3ClientEvents {
243 pub fn push_promise(&self, push_id: PushId, request_stream_id: StreamId, headers: Vec<Header>) {
244 self.insert(Http3ClientEvent::PushPromise {
245 push_id,
246 request_stream_id,
247 headers,
248 });
249 }
250
251 pub fn push_canceled(&self, push_id: PushId) {
252 self.remove_events_for_push_id(push_id);
253 self.insert(Http3ClientEvent::PushCanceled { push_id });
254 }
255
256 pub fn push_reset(&self, push_id: PushId, error: AppError) {
257 self.remove_events_for_push_id(push_id);
258 self.insert(Http3ClientEvent::PushReset { push_id, error });
259 }
260
261 /// Add a new `RequestCreatable` event
262 pub(crate) fn new_requests_creatable(&self, stream_type: StreamType) {
263 if stream_type == StreamType::BiDi {
264 self.insert(Http3ClientEvent::RequestsCreatable);
265 }
266 }
267
268 /// Add a new `AuthenticationNeeded` event
269 pub(crate) fn authentication_needed(&self) {
270 self.insert(Http3ClientEvent::AuthenticationNeeded);
271 }
272
273 /// Add a new `AuthenticationNeeded` event
274 pub(crate) fn ech_fallback_authentication_needed(&self, public_name: String) {
275 self.insert(Http3ClientEvent::EchFallbackAuthenticationNeeded { public_name });
276 }
277
278 /// Add a new resumption token event.
279 pub(crate) fn resumption_token(&self, token: ResumptionToken) {
280 self.insert(Http3ClientEvent::ResumptionToken(token));
281 }
282
283 /// Add a new `ZeroRttRejected` event.
284 pub(crate) fn zero_rtt_rejected(&self) {
285 self.insert(Http3ClientEvent::ZeroRttRejected);
286 }
287
288 /// Add a new `GoawayReceived` event.
289 pub(crate) fn goaway_received(&self) {
290 self.remove(|evt| matches!(evt, Http3ClientEvent::RequestsCreatable));
291 self.insert(Http3ClientEvent::GoawayReceived);
292 }
293
294 pub fn insert(&self, event: Http3ClientEvent) {
295 self.events.borrow_mut().push_back(event);
296 }
297
298 fn remove<F>(&self, f: F)
299 where
300 F: Fn(&Http3ClientEvent) -> bool,
301 {
302 self.events.borrow_mut().retain(|evt| !f(evt));
303 }
304
305 /// Add a new `StateChange` event.
306 pub(crate) fn connection_state_change(&self, state: Http3State) {
307 match state {
308 // If closing, existing events no longer relevant.
309 Http3State::Closing { .. } | Http3State::Closed(_) => self.events.borrow_mut().clear(),
310 Http3State::Connected => {
311 self.remove(|evt| {
312 matches!(evt, Http3ClientEvent::StateChange(Http3State::ZeroRtt))
313 });
314 }
315 _ => (),
316 }
317 self.insert(Http3ClientEvent::StateChange(state));
318 }
319
320 /// Remove all events for a stream
321 fn remove_recv_stream_events(&self, stream_id: StreamId) {
322 self.remove(|evt| {
323 matches!(evt,
324 Http3ClientEvent::HeaderReady { stream_id: x, .. }
325 | Http3ClientEvent::DataReadable { stream_id: x }
326 | Http3ClientEvent::PushPromise { request_stream_id: x, .. }
327 | Http3ClientEvent::Reset { stream_id: x, .. } if *x == stream_id)
328 });
329 }
330
331 fn remove_send_stream_events(&self, stream_id: StreamId) {
332 self.remove(|evt| {
333 matches!(evt,
334 Http3ClientEvent::DataWritable { stream_id: x }
335 | Http3ClientEvent::StopSending { stream_id: x, .. } if *x == stream_id)
336 });
337 }
338
339 pub fn has_push(&self, push_id: PushId) -> bool {
340 for iter in &*self.events.borrow() {
341 if matches!(iter, Http3ClientEvent::PushPromise{push_id:x, ..} if *x == push_id) {
342 return true;
343 }
344 }
345 false
346 }
347
348 pub fn remove_events_for_push_id(&self, push_id: PushId) {
349 self.remove(|evt| {
350 matches!(evt,
351 Http3ClientEvent::PushPromise{ push_id: x, .. }
352 | Http3ClientEvent::PushHeaderReady{ push_id: x, .. }
353 | Http3ClientEvent::PushDataReadable{ push_id: x, .. }
354 | Http3ClientEvent::PushCanceled{ push_id: x, .. } if *x == push_id)
355 });
356 }
357
358 pub fn negotiation_done(&self, feature_type: HSettingType, succeeded: bool) {
359 if feature_type == HSettingType::EnableWebTransport {
360 self.insert(Http3ClientEvent::WebTransport(
361 WebTransportEvent::Negotiated(succeeded),
362 ));
363 }
364 }
365 }
366
367 impl EventProvider for Http3ClientEvents {
368 type Event = Http3ClientEvent;
369
370 /// Check if there is any event present.
371 fn has_events(&self) -> bool {
372 !self.events.borrow().is_empty()
373 }
374
375 /// Take the first event.
376 fn next_event(&mut self) -> Option<Self::Event> {
377 self.events.borrow_mut().pop_front()
378 }
379 }