checkpoint: integrate authenticated transports

tests/quic.rs

@@ -1,14 +1,3 @@
-#[path = "../src/config.rs"]
-mod config;
-#[path = "../src/datagram.rs"]
-mod datagram;
-#[path = "../src/protocol/mod.rs"]
-mod protocol;
-#[path = "../src/stats.rs"]
-mod stats;
-#[path = "../src/transport/mod.rs"]
-mod transport;
-
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use base64::Engine;
@@ -16,9 +5,12 @@ use bytes::Bytes;
 use quinn::{ClientConfig as QuinnClientConfig, Endpoint, ServerConfig as QuinnServerConfig};
 use rustls::pki_types::{CertificateDer, PrivatePkcs8KeyDer};
 use tokio::time::timeout;
-use transport::{
-    quic::{QuicClientConnector, QuicServer},
-    TransportError, TransportSession,
+use wgcloak::{
+    config,
+    transport::{
+        quic::{QuicClientConnector, QuicServer},
+        AdmissionController, TransportError, TransportSession,
+    },
 };
 
 const SECRET: &str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
@@ -71,12 +63,34 @@ async fn authenticated_datagram_round_trip_and_limit() {
             .decode(SECRET)
             .unwrap(),
     );
-    let server = QuicServer::from_endpoint(endpoint, clients, 1200, Duration::from_secs(2));
-    let port = server.local_addr().unwrap().port();
+    let admission = AdmissionController::new(&config::LimitsConfig::default());
+    let server = QuicServer::from_endpoint_with_admission(
+        endpoint,
+        clients,
+        1200,
+        Duration::from_secs(2),
+        admission.clone(),
+    );
+    let server_addr = server.local_addr().unwrap();
+    let port = server_addr.port();
     let client = QuicClientConnector::with_client_config(client_config(port, SECRET), client_tls);
     let server_task = tokio::spawn(async move { server.accept().await });
     let client_session = client.connect_session().await.unwrap();
     let server_session = server_task.await.unwrap().unwrap();
+    let remote_addr = client_session.remote_addr().unwrap();
+    assert_eq!(remote_addr.port(), server_addr.port());
+    assert!(match remote_addr.ip() {
+        std::net::IpAddr::V4(address) => address.is_loopback(),
+        std::net::IpAddr::V6(address) => {
+            address.is_loopback()
+                || address
+                    .to_ipv4_mapped()
+                    .map(|mapped| mapped.is_loopback())
+                    .unwrap_or(false)
+        }
+    });
+    assert!(client_session.rtt().is_some());
+    assert_eq!(client_session.authenticated_keepalive_interval(), None);
     client_session
         .send_datagram(Bytes::from_static(b"opaque"))
         .await
@@ -88,6 +102,7 @@ async fn authenticated_datagram_round_trip_and_limit() {
             .unwrap(),
         Bytes::from_static(b"opaque")
     );
+    assert_eq!(admission.active_sessions(), 1);
     assert!(matches!(
         client_session
             .send_datagram(Bytes::from(vec![0; 1201]))
@@ -96,6 +111,7 @@ async fn authenticated_datagram_round_trip_and_limit() {
     ));
     client_session.close().await.unwrap();
     server_session.close().await.unwrap();
+    assert_eq!(admission.active_sessions(), 0);
 }
 
 #[tokio::test]