Debian Codegraph @

third_party/rust/neqo-http3/src/server_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::{
8 cell::RefCell,
9 collections::VecDeque,
10 fmt::{self, Display, Formatter},
11 ops::{Deref, DerefMut},
12 rc::Rc,
13 };
14
15 use neqo_common::{qdebug, Encoder, Header};
16 use neqo_transport::{
17 server::ConnectionRef, AppError, Connection, DatagramTracking, StreamId, StreamType,
18 };
19
20 use crate::{
21 connection::{Http3State, WebTransportSessionAcceptAction},
22 connection_server::Http3ServerHandler,
23 features::extended_connect::SessionCloseReason,
24 Error, Http3StreamInfo, Http3StreamType, Priority, Res,
25 };
26
27 #[derive(Debug, Clone)]
28 pub struct StreamHandler {
29 pub conn: ConnectionRef,
30 pub handler: Rc<RefCell<Http3ServerHandler>>,
31 pub stream_info: Http3StreamInfo,
32 }
33
34 impl Display for StreamHandler {
35 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
36 let conn: &Connection = &self.conn.borrow();
37 write!(f, "conn={conn} stream_info={:?}", self.stream_info)
38 }
39 }
40
41 impl std::hash::Hash for StreamHandler {
42 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
43 self.conn.hash(state);
44 state.write_u64(self.stream_info.stream_id().as_u64());
45 _ = state.finish();
46 }
47 }
48
49 impl PartialEq for StreamHandler {
50 fn eq(&self, other: &Self) -> bool {
51 self.conn == other.conn && self.stream_info.stream_id() == other.stream_info.stream_id()
52 }
53 }
54
55 impl StreamHandler {
56 pub const fn stream_id(&self) -> StreamId {
57 self.stream_info.stream_id()
58 }
59
60 /// Supply a response header to a request.
61 ///
62 /// # Errors
63 ///
64 /// It may return `InvalidStreamId` if a stream does not exist anymore.
65 pub fn send_headers(&self, headers: &[Header]) -> Res<()> {
66 self.handler.borrow_mut().send_headers(
67 self.stream_id(),
68 headers,
69 &mut self.conn.borrow_mut(),
70 )
71 }
72
73 /// Supply response data to a request.
74 ///
75 /// # Errors
76 ///
77 /// It may return `InvalidStreamId` if a stream does not exist anymore.
78 pub fn send_data(&self, buf: &[u8]) -> Res<usize> {
79 self.handler
80 .borrow_mut()
81 .send_data(self.stream_id(), buf, &mut self.conn.borrow_mut())
82 }
83
84 /// Bytes sendable on stream at the QUIC layer.
85 ///
86 /// Note that this does not yet account for HTTP3 frame headers.
87 ///
88 /// # Errors
89 ///
90 /// It may return `InvalidStreamId` if a stream does not exist anymore.
91 pub fn available(&self) -> Res<usize> {
92 let stream_id = self.stream_id();
93 let n = self.conn.borrow_mut().stream_avail_send_space(stream_id)?;
94 Ok(n)
95 }
96
97 /// Close sending side.
98 ///
99 /// # Errors
100 ///
101 /// It may return `InvalidStreamId` if a stream does not exist anymore.
102 pub fn stream_close_send(&self) -> Res<()> {
103 self.handler
104 .borrow_mut()
105 .stream_close_send(self.stream_id(), &mut self.conn.borrow_mut())
106 }
107
108 /// Request a peer to stop sending a stream.
109 ///
110 /// # Errors
111 ///
112 /// It may return `InvalidStreamId` if a stream does not exist anymore.
113 pub fn stream_stop_sending(&self, app_error: AppError) -> Res<()> {
114 qdebug!(
115 "[{self}] stop sending stream_id:{} error:{app_error}",
116 self.stream_info.stream_id()
117 );
118 self.handler.borrow_mut().stream_stop_sending(
119 self.stream_info.stream_id(),
120 app_error,
121 &mut self.conn.borrow_mut(),
122 )
123 }
124
125 /// Reset sending side of a stream.
126 ///
127 /// # Errors
128 ///
129 /// It may return `InvalidStreamId` if a stream does not exist anymore.
130 pub fn stream_reset_send(&self, app_error: AppError) -> Res<()> {
131 qdebug!(
132 "[{self}] reset send stream_id:{} error:{app_error}",
133 self.stream_info.stream_id()
134 );
135 self.handler.borrow_mut().stream_reset_send(
136 self.stream_info.stream_id(),
137 app_error,
138 &mut self.conn.borrow_mut(),
139 )
140 }
141
142 /// Reset a stream/request.
143 ///
144 /// # Errors
145 ///
146 /// It may return `InvalidStreamId` if a stream does not exist anymore
147 pub fn cancel_fetch(&self, app_error: AppError) -> Res<()> {
148 qdebug!("[{self}] reset error:{app_error}");
149 self.handler.borrow_mut().cancel_fetch(
150 self.stream_info.stream_id(),
151 app_error,
152 &mut self.conn.borrow_mut(),
153 )
154 }
155 }
156
157 #[derive(Debug, Clone)]
158 pub struct Http3OrWebTransportStream {
159 stream_handler: StreamHandler,
160 }
161
162 impl Display for Http3OrWebTransportStream {
163 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
164 write!(f, "Stream server {:?}", self.stream_handler)
165 }
166 }
167
168 impl Http3OrWebTransportStream {
169 pub(crate) const fn new(
170 conn: ConnectionRef,
171 handler: Rc<RefCell<Http3ServerHandler>>,
172 stream_info: Http3StreamInfo,
173 ) -> Self {
174 Self {
175 stream_handler: StreamHandler {
176 conn,
177 handler,
178 stream_info,
179 },
180 }
181 }
182
183 /// Supply a response header to a request.
184 ///
185 /// # Errors
186 ///
187 /// It may return `InvalidStreamId` if a stream does not exist anymore.
188 pub fn send_headers(&self, headers: &[Header]) -> Res<()> {
189 self.stream_handler.send_headers(headers)
190 }
191
192 /// Supply response data to a request.
193 ///
194 /// # Errors
195 ///
196 /// It may return `InvalidStreamId` if a stream does not exist anymore.
197 pub fn send_data(&self, data: &[u8]) -> Res<usize> {
198 qdebug!("[{self}] Set new response");
199 self.stream_handler.send_data(data)
200 }
201
202 /// Close sending side.
203 ///
204 /// # Errors
205 ///
206 /// It may return `InvalidStreamId` if a stream does not exist anymore.
207 pub fn stream_close_send(&self) -> Res<()> {
208 qdebug!("[{self}] Set new response");
209 self.stream_handler.stream_close_send()
210 }
211 }
212
213 impl Deref for Http3OrWebTransportStream {
214 type Target = StreamHandler;
215 fn deref(&self) -> &Self::Target {
216 &self.stream_handler
217 }
218 }
219
220 impl DerefMut for Http3OrWebTransportStream {
221 fn deref_mut(&mut self) -> &mut StreamHandler {
222 &mut self.stream_handler
223 }
224 }
225
226 impl std::hash::Hash for Http3OrWebTransportStream {
227 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
228 self.stream_handler.hash(state);
229 _ = state.finish();
230 }
231 }
232
233 impl PartialEq for Http3OrWebTransportStream {
234 fn eq(&self, other: &Self) -> bool {
235 self.stream_handler == other.stream_handler
236 }
237 }
238
239 impl Eq for Http3OrWebTransportStream {}
240
241 #[derive(Debug, Clone)]
242 pub struct WebTransportRequest {
243 stream_handler: StreamHandler,
244 }
245
246 impl Display for WebTransportRequest {
247 fn fmt(&self, f: &mut Formatter) -> fmt::Result {
248 write!(f, "WebTransport session {}", self.stream_handler)
249 }
250 }
251
252 impl WebTransportRequest {
253 pub(crate) const fn new(
254 conn: ConnectionRef,
255 handler: Rc<RefCell<Http3ServerHandler>>,
256 stream_id: StreamId,
257 ) -> Self {
258 Self {
259 stream_handler: StreamHandler {
260 conn,
261 handler,
262 stream_info: Http3StreamInfo::new(stream_id, Http3StreamType::Http),
263 },
264 }
265 }
266
267 #[must_use]
268 pub fn state(&self) -> Http3State {
269 self.stream_handler.handler.borrow().state()
270 }
271
272 /// Respond to a `WebTransport` session request.
273 ///
274 /// # Errors
275 ///
276 /// It may return `InvalidStreamId` if a stream does not exist anymore.
277 pub fn response(&self, accept: &WebTransportSessionAcceptAction) -> Res<()> {
278 qdebug!("[{self}] Set a response for a WebTransport session");
279 self.stream_handler
280 .handler
281 .borrow_mut()
282 .webtransport_session_accept(
283 &mut self.stream_handler.conn.borrow_mut(),
284 self.stream_handler.stream_info.stream_id(),
285 accept,
286 )
287 }
288
289 /// # Errors
290 ///
291 /// It may return `InvalidStreamId` if a stream does not exist anymore.
292 /// Also return an error if the stream was closed on the transport layer,
293 /// but that information is not yet consumed on the http/3 layer.
294 pub fn close_session(&self, error: u32, message: &str) -> Res<()> {
295 self.stream_handler
296 .handler
297 .borrow_mut()
298 .webtransport_close_session(
299 &mut self.stream_handler.conn.borrow_mut(),
300 self.stream_handler.stream_info.stream_id(),
301 error,
302 message,
303 )
304 }
305
306 #[must_use]
307 pub const fn stream_id(&self) -> StreamId {
308 self.stream_handler.stream_id()
309 }
310
311 /// Close sending side.
312 ///
313 /// # Errors
314 ///
315 /// It may return `InvalidStreamId` if a stream does not exist anymore.
316 pub fn create_stream(&self, stream_type: StreamType) -> Res<Http3OrWebTransportStream> {
317 let session_id = self.stream_handler.stream_id();
318 let id = self
319 .stream_handler
320 .handler
321 .borrow_mut()
322 .webtransport_create_stream(
323 &mut self.stream_handler.conn.borrow_mut(),
324 session_id,
325 stream_type,
326 )?;
327
328 Ok(Http3OrWebTransportStream::new(
329 self.stream_handler.conn.clone(),
330 Rc::clone(&self.stream_handler.handler),
331 Http3StreamInfo::new(id, Http3StreamType::WebTransport(session_id)),
332 ))
333 }
334
335 /// Send `WebTransport` datagram.
336 ///
337 /// # Errors
338 ///
339 /// It may return `InvalidStreamId` if a stream does not exist anymore.
340 /// The function returns `TooMuchData` if the supply buffer is bigger than
341 /// the allowed remote datagram size.
342 pub fn send_datagram(&self, buf: &[u8], id: impl Into<DatagramTracking>) -> Res<()> {
343 let session_id = self.stream_handler.stream_id();
344 self.stream_handler
345 .handler
346 .borrow_mut()
347 .webtransport_send_datagram(
348 &mut self.stream_handler.conn.borrow_mut(),
349 session_id,
350 buf,
351 id,
352 )
353 }
354
355 #[must_use]
356 pub fn remote_datagram_size(&self) -> u64 {
357 self.stream_handler.conn.borrow().remote_datagram_size()
358 }
359
360 /// Returns the current max size of a datagram that can fit into a packet.
361 /// The value will change over time depending on the encoded size of the
362 /// packet number, ack frames, etc.
363 ///
364 /// # Errors
365 ///
366 /// The function returns `NotAvailable` if datagrams are not enabled.
367 ///
368 /// # Panics
369 ///
370 /// This cannot panic. The max varint length is 8.
371 pub fn max_datagram_size(&self) -> Res<u64> {
372 let max_size = self.stream_handler.conn.borrow().max_datagram_size()?;
373 Ok(max_size
374 - u64::try_from(Encoder::varint_len(
375 self.stream_handler.stream_id().as_u64(),
376 ))
377 .map_err(|_| Error::Internal)?)
378 }
379 }
380
381 impl Deref for WebTransportRequest {
382 type Target = StreamHandler;
383 fn deref(&self) -> &Self::Target {
384 &self.stream_handler
385 }
386 }
387
388 impl DerefMut for WebTransportRequest {
389 fn deref_mut(&mut self) -> &mut StreamHandler {
390 &mut self.stream_handler
391 }
392 }
393
394 impl std::hash::Hash for WebTransportRequest {
395 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
396 self.stream_handler.hash(state);
397 _ = state.finish();
398 }
399 }
400
401 impl PartialEq for WebTransportRequest {
402 fn eq(&self, other: &Self) -> bool {
403 self.stream_handler == other.stream_handler
404 }
405 }
406
407 #[derive(Debug, Clone)]
408 pub enum WebTransportServerEvent {
409 NewSession {
410 session: WebTransportRequest,
411 headers: Vec<Header>,
412 },
413 SessionClosed {
414 session: WebTransportRequest,
415 reason: SessionCloseReason,
416 headers: Option<Vec<Header>>,
417 },
418 NewStream(Http3OrWebTransportStream),
419 Datagram {
420 session: WebTransportRequest,
421 datagram: Vec<u8>,
422 },
423 }
424
425 #[derive(Debug, Clone)]
426 pub enum Http3ServerEvent {
427 /// Headers are ready.
428 Headers {
429 stream: Http3OrWebTransportStream,
430 headers: Vec<Header>,
431 fin: bool,
432 },
433 /// Request data is ready.
434 Data {
435 stream: Http3OrWebTransportStream,
436 data: Vec<u8>,
437 fin: bool,
438 },
439 DataWritable {
440 stream: Http3OrWebTransportStream,
441 },
442 StreamReset {
443 stream: Http3OrWebTransportStream,
444 error: AppError,
445 },
446 StreamStopSending {
447 stream: Http3OrWebTransportStream,
448 error: AppError,
449 },
450 /// When individual connection change state. It is only used for tests.
451 StateChange {
452 conn: ConnectionRef,
453 state: Http3State,
454 },
455 PriorityUpdate {
456 stream_id: StreamId,
457 priority: Priority,
458 },
459 WebTransport(WebTransportServerEvent),
460 }
461
462 #[derive(Debug, Default, Clone)]
463 pub struct Http3ServerEvents {
464 events: Rc<RefCell<VecDeque<Http3ServerEvent>>>,
465 }
466
467 impl Http3ServerEvents {
468 fn insert(&self, event: Http3ServerEvent) {
469 self.events.borrow_mut().push_back(event);
470 }
471
472 /// Take all events
473 pub fn events(&self) -> impl Iterator<Item = Http3ServerEvent> {
474 self.events.replace(VecDeque::new()).into_iter()
475 }
476
477 /// Whether there is request pending.
478 pub fn has_events(&self) -> bool {
479 !self.events.borrow().is_empty()
480 }
481
482 /// Take the next event if present.
483 pub fn next_event(&self) -> Option<Http3ServerEvent> {
484 self.events.borrow_mut().pop_front()
485 }
486
487 /// Insert a `Headers` event.
488 pub(crate) fn headers(
489 &self,
490 request: Http3OrWebTransportStream,
491 headers: Vec<Header>,
492 fin: bool,
493 ) {
494 self.insert(Http3ServerEvent::Headers {
495 stream: request,
496 headers,
497 fin,
498 });
499 }
500
501 /// Insert a `StateChange` event.
502 pub(crate) fn connection_state_change(&self, conn: ConnectionRef, state: Http3State) {
503 self.insert(Http3ServerEvent::StateChange { conn, state });
504 }
505
506 /// Insert a `Data` event.
507 pub(crate) fn data(
508 &self,
509 conn: ConnectionRef,
510 handler: Rc<RefCell<Http3ServerHandler>>,
511 stream_info: Http3StreamInfo,
512 data: Vec<u8>,
513 fin: bool,
514 ) {
515 self.insert(Http3ServerEvent::Data {
516 stream: Http3OrWebTransportStream::new(conn, handler, stream_info),
517 data,
518 fin,
519 });
520 }
521
522 pub(crate) fn data_writable(
523 &self,
524 conn: ConnectionRef,
525 handler: Rc<RefCell<Http3ServerHandler>>,
526 stream_info: Http3StreamInfo,
527 ) {
528 self.insert(Http3ServerEvent::DataWritable {
529 stream: Http3OrWebTransportStream::new(conn, handler, stream_info),
530 });
531 }
532
533 pub(crate) fn stream_reset(
534 &self,
535 conn: ConnectionRef,
536 handler: Rc<RefCell<Http3ServerHandler>>,
537 stream_info: Http3StreamInfo,
538 error: AppError,
539 ) {
540 self.insert(Http3ServerEvent::StreamReset {
541 stream: Http3OrWebTransportStream::new(conn, handler, stream_info),
542 error,
543 });
544 }
545
546 pub(crate) fn stream_stop_sending(
547 &self,
548 conn: ConnectionRef,
549 handler: Rc<RefCell<Http3ServerHandler>>,
550 stream_info: Http3StreamInfo,
551 error: AppError,
552 ) {
553 self.insert(Http3ServerEvent::StreamStopSending {
554 stream: Http3OrWebTransportStream::new(conn, handler, stream_info),
555 error,
556 });
557 }
558
559 pub(crate) fn priority_update(&self, stream_id: StreamId, priority: Priority) {
560 self.insert(Http3ServerEvent::PriorityUpdate {
561 stream_id,
562 priority,
563 });
564 }
565
566 pub(crate) fn webtransport_new_session(
567 &self,
568 session: WebTransportRequest,
569 headers: Vec<Header>,
570 ) {
571 self.insert(Http3ServerEvent::WebTransport(
572 WebTransportServerEvent::NewSession { session, headers },
573 ));
574 }
575
576 pub(crate) fn webtransport_session_closed(
577 &self,
578 session: WebTransportRequest,
579 reason: SessionCloseReason,
580 headers: Option<Vec<Header>>,
581 ) {
582 self.insert(Http3ServerEvent::WebTransport(
583 WebTransportServerEvent::SessionClosed {
584 session,
585 reason,
586 headers,
587 },
588 ));
589 }
590
591 pub(crate) fn webtransport_new_stream(&self, stream: Http3OrWebTransportStream) {
592 self.insert(Http3ServerEvent::WebTransport(
593 WebTransportServerEvent::NewStream(stream),
594 ));
595 }
596
597 pub(crate) fn webtransport_datagram(&self, session: WebTransportRequest, datagram: Vec<u8>) {
598 self.insert(Http3ServerEvent::WebTransport(
599 WebTransportServerEvent::Datagram { session, datagram },
600 ));
601 }
602 }