rwebtransport 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -18,6 +18,8 @@ use std::sync::Arc;
18
18
  use mio::net::UdpSocket;
19
19
  use mio::{Events, Interest, Poll};
20
20
 
21
+ use wtcore::h3;
22
+
21
23
  use crate::config::build_server_config;
22
24
  use crate::driver::{DriverShared, SOCKET_TOKEN};
23
25
  use crate::session::{Ev, WtSession};
@@ -44,6 +46,13 @@ pub struct ServerSetup {
44
46
  /// workers) can share one listening port and have the kernel load-balance
45
47
  /// connections across them.
46
48
  pub reuse_port: bool,
49
+ /// WebTransport subprotocols the server supports (preference order).
50
+ pub supported_protocols: Vec<String>,
51
+ /// If `Some`, only Extended CONNECTs whose `origin` is in this list are
52
+ /// accepted; others are rejected with 403. `None` allows any origin.
53
+ pub allowed_origins: Option<Vec<String>>,
54
+ /// Extra headers to add to every 200 CONNECT response.
55
+ pub response_headers: Vec<(String, String)>,
47
56
  }
48
57
 
49
58
  /// Bind a non-blocking UDP socket, optionally with `SO_REUSEPORT` for clustering.
@@ -108,6 +117,24 @@ pub enum ServerCommand {
108
117
  code: u32,
109
118
  reason: Vec<u8>,
110
119
  },
120
+ /// Send a DRAIN_WEBTRANSPORT_SESSION capsule to one session's peer.
121
+ Drain {
122
+ session: u64,
123
+ },
124
+ /// Snapshot one session's connection stats; result arrives as a `stats` event.
125
+ GetStats {
126
+ session: u64,
127
+ request_id: u64,
128
+ },
129
+ /// Export TLS keying material (RFC 5705) for one session; result arrives as
130
+ /// a `keyingMaterial` event.
131
+ ExportKeyingMaterial {
132
+ session: u64,
133
+ request_id: u64,
134
+ label: Vec<u8>,
135
+ context: Vec<u8>,
136
+ length: u32,
137
+ },
111
138
  /// Tear the whole server down.
112
139
  Shutdown,
113
140
  }
@@ -428,7 +455,12 @@ fn run_inner(
428
455
  key.clone(),
429
456
  ServerConn {
430
457
  conn,
431
- session: WtSession::new_server(from),
458
+ session: WtSession::new_server(
459
+ from,
460
+ setup.supported_protocols.clone(),
461
+ setup.allowed_origins.clone(),
462
+ setup.response_headers.clone(),
463
+ ),
432
464
  session_id,
433
465
  closed_emitted: false,
434
466
  },
@@ -476,7 +508,7 @@ fn run_inner(
476
508
  for server in clients.values_mut() {
477
509
  let mut evs: Vec<Ev> = Vec::new();
478
510
  if server.conn.is_established() {
479
- server.session.on_established(&mut evs);
511
+ server.session.on_established();
480
512
  }
481
513
  if !backpressured {
482
514
  server.session.on_datagrams(&mut server.conn, &mut evs);
@@ -494,7 +526,7 @@ fn run_inner(
494
526
  // lingering as a zombie until the idle timeout.
495
527
  if server.session.is_closed() && !server.conn.is_closed() && !server.conn.is_draining()
496
528
  {
497
- let _ = server.conn.close(true, 0, b"session closed");
529
+ let _ = server.conn.close(true, h3::H3_NO_ERROR, b"");
498
530
  }
499
531
 
500
532
  if let Some(sz) = server.conn.dgram_max_writable_len() {
@@ -515,9 +547,18 @@ fn run_inner(
515
547
  if server.conn.is_closed() && !server.closed_emitted {
516
548
  server.closed_emitted = true;
517
549
  if !server.session.is_closed() {
518
- let (code, reason, remote) = closure_info(&server.conn);
519
550
  let mut evs = Vec::new();
520
- server.session.mark_closed(&mut evs, code, reason, remote);
551
+ if let Some((code, reason)) = server.session.local_close_info() {
552
+ // Locally initiated graceful WebTransport close: surface the
553
+ // WT code/reason (the wire close used H3_NO_ERROR).
554
+ server.session.mark_closed(&mut evs, code, reason, false);
555
+ } else {
556
+ let (code, reason, remote, err) = closure_info(&server.conn);
557
+ if let Some(msg) = err {
558
+ evs.push(Ev::Error(msg));
559
+ }
560
+ server.session.mark_closed(&mut evs, code, reason, remote);
561
+ }
521
562
  for ev in evs {
522
563
  out.push(ServerMsg::Session(server.session_id, ev));
523
564
  }
@@ -556,7 +597,10 @@ fn apply_command(
556
597
  | ServerCommand::StopSending { session, .. }
557
598
  | ServerCommand::SetPaused { session, .. }
558
599
  | ServerCommand::SendDatagram { session, .. }
559
- | ServerCommand::CloseSession { session, .. } => *session,
600
+ | ServerCommand::CloseSession { session, .. }
601
+ | ServerCommand::Drain { session }
602
+ | ServerCommand::GetStats { session, .. }
603
+ | ServerCommand::ExportKeyingMaterial { session, .. } => *session,
560
604
  ServerCommand::Shutdown => return,
561
605
  };
562
606
  let Some(scid) = sessions.get(&session_id) else {
@@ -594,6 +638,23 @@ fn apply_command(
594
638
  .session
595
639
  .send_datagram(&mut server.conn, &data, request_id, &mut evs),
596
640
  ServerCommand::CloseSession { code, reason, .. } => server.session.close(code, reason),
641
+ ServerCommand::Drain { .. } => server.session.send_drain(),
642
+ ServerCommand::GetStats { request_id, .. } => {
643
+ evs.push(crate::session::build_stats(&server.conn, request_id))
644
+ }
645
+ ServerCommand::ExportKeyingMaterial {
646
+ request_id,
647
+ label,
648
+ context,
649
+ length,
650
+ ..
651
+ } => evs.push(crate::session::build_keying_material(
652
+ &mut server.conn,
653
+ request_id,
654
+ &label,
655
+ &context,
656
+ length,
657
+ )),
597
658
  ServerCommand::Shutdown => {}
598
659
  }
599
660
  // Surface events produced synchronously by the command (StreamOpened,
@@ -622,14 +683,54 @@ fn flush_send(conn: &mut quiche::Connection, socket: &UdpSocket, out: &mut [u8])
622
683
  }
623
684
  }
624
685
 
625
- fn closure_info(conn: &quiche::Connection) -> (u32, Vec<u8>, bool) {
686
+ /// Extract a close code/reason from a terminated connection. The fourth element
687
+ /// is `Some(message)` for an abnormal transport-level termination (idle timeout,
688
+ /// transport CONNECTION_CLOSE with `is_app == false`, stateless reset), which is
689
+ /// surfaced as an `Ev::Error` so the JS `closed` promise rejects; a clean
690
+ /// application close keeps its WebTransport code/reason and returns `None`.
691
+ fn closure_info(conn: &quiche::Connection) -> (u32, Vec<u8>, bool, Option<String>) {
626
692
  if let Some(err) = conn.peer_error() {
627
- return (err.error_code as u32, err.reason.clone(), true);
693
+ if err.is_app {
694
+ return (err.error_code as u32, err.reason.clone(), true, None);
695
+ }
696
+ return (
697
+ 0,
698
+ Vec::new(),
699
+ true,
700
+ Some(format!(
701
+ "connection terminated by peer transport error {:#x}",
702
+ err.error_code
703
+ )),
704
+ );
628
705
  }
629
706
  if let Some(err) = conn.local_error() {
630
- return (err.error_code as u32, err.reason.clone(), false);
707
+ if err.is_app {
708
+ return (err.error_code as u32, err.reason.clone(), false, None);
709
+ }
710
+ return (
711
+ 0,
712
+ Vec::new(),
713
+ false,
714
+ Some(format!(
715
+ "connection closed by transport error {:#x}",
716
+ err.error_code
717
+ )),
718
+ );
719
+ }
720
+ if conn.is_timed_out() {
721
+ return (
722
+ 0,
723
+ Vec::new(),
724
+ false,
725
+ Some("connection timed out".to_string()),
726
+ );
631
727
  }
632
- (0, Vec::new(), true)
728
+ (
729
+ 0,
730
+ Vec::new(),
731
+ true,
732
+ Some("connection closed abnormally".to_string()),
733
+ )
633
734
  }
634
735
 
635
736
  #[cfg(test)]