feat(iroh-net-report)!: add QUIC address discovery probes

iroh-net-report/Cargo.toml

@@ -27,6 +27,7 @@ iroh-metrics = { version = "0.29.0", default-features = false }
 iroh-relay = { version = "0.29", path = "../iroh-relay" }
 netwatch = { version = "0.2.0" }
 portmapper = { version = "0.2.0", default-features = false }
+quinn = { package = "iroh-quinn", version = "0.12.0" }
 rand = "0.8"
 reqwest = { version = "0.12", default-features = false }
 rustls = { version = "0.23", default-features = false }

iroh-net-report/src/defaults.rs

@@ -1,9 +1,6 @@
 //! Default values used in net_report.
 
-/// The default STUN port used by the Relay server.
-///
-/// The STUN port as defined by [RFC 8489](<https://www.rfc-editor.org/rfc/rfc8489#section-18.6>)
-pub const DEFAULT_STUN_PORT: u16 = 3478;
+pub(crate) use iroh_base::relay_map::{DEFAULT_RELAY_QUIC_PORT, DEFAULT_STUN_PORT};
 
 /// Contains all timeouts that we use in `iroh-net-report`.
 pub(crate) mod timeouts {

iroh-net-report/src/lib.rs

@@ -34,6 +34,7 @@ mod ping;
 mod reportgen;
 
 pub use metrics::Metrics;
+pub use reportgen::QuicConfig;
 
 const FULL_REPORT_INTERVAL: Duration = Duration::from_secs(5 * 60);
 
@@ -240,13 +241,23 @@ impl Client {
     ///
     /// If these are not passed in this will bind sockets for STUN itself, though results
     /// may not be as reliable.
+    ///
+    /// The *quic_config* takes a [`QuicConfig`], a combination of a QUIC endpoint and
+    /// a client configuration that can be use for verifying the relay server connection.
+    /// When available, the report will attempt to get an observed public address
+    /// using QUIC address discovery.
+    ///
+    /// When `None`, it will disable the QUIC address discovery probes.
     pub async fn get_report(
         &mut self,
         dm: RelayMap,
         stun_conn4: Option<Arc<UdpSocket>>,
         stun_conn6: Option<Arc<UdpSocket>>,
+        quic_config: Option<QuicConfig>,
     ) -> Result<Arc<Report>> {
-        let rx = self.get_report_channel(dm, stun_conn4, stun_conn6).await?;
+        let rx = self
+            .get_report_channel(dm, stun_conn4, stun_conn6, quic_config)
+            .await?;
         match rx.await {
             Ok(res) => res,
             Err(_) => Err(anyhow!("channel closed, actor awol")),
@@ -259,6 +270,7 @@ impl Client {
         dm: RelayMap,
         stun_conn4: Option<Arc<UdpSocket>>,
         stun_conn6: Option<Arc<UdpSocket>>,
+        quic_config: Option<QuicConfig>,
     ) -> Result<oneshot::Receiver<Result<Arc<Report>>>> {
         // TODO: consider if RelayMap should be made to easily clone?  It seems expensive
         // right now.
@@ -268,6 +280,7 @@ impl Client {
                 relay_map: dm,
                 stun_sock_v4: stun_conn4,
                 stun_sock_v6: stun_conn6,
+                quic_config,
                 response_tx: tx,
             })
             .await?;
@@ -307,6 +320,11 @@ pub(crate) enum Message {
         ///
         /// Like `stun_sock_v4` but for IPv6.
         stun_sock_v6: Option<Arc<UdpSocket>>,
+        /// Endpoint and client configuration to create a QUIC
+        /// connection to do QUIC address discovery.
+        ///
+        /// If not provided, will not do QUIC address discovery.
+        quic_config: Option<QuicConfig>,
         /// Channel to receive the response.
         response_tx: oneshot::Sender<Result<Arc<Report>>>,
     },
@@ -446,9 +464,16 @@ impl Actor {
                     relay_map,
                     stun_sock_v4,
                     stun_sock_v6,
+                    quic_config,
                     response_tx,
                 } => {
-                    self.handle_run_check(relay_map, stun_sock_v4, stun_sock_v6, response_tx);
+                    self.handle_run_check(
+                        relay_map,
+                        stun_sock_v4,
+                        stun_sock_v6,
+                        quic_config,
+                        response_tx,
+                    );
                 }
                 Message::ReportReady { report } => {
                     self.handle_report_ready(report);
@@ -476,6 +501,7 @@ impl Actor {
         relay_map: RelayMap,
         stun_sock_v4: Option<Arc<UdpSocket>>,
         stun_sock_v6: Option<Arc<UdpSocket>>,
+        quic_config: Option<QuicConfig>,
         response_tx: oneshot::Sender<Result<Arc<Report>>>,
     ) {
         if self.current_report_run.is_some() {
@@ -526,6 +552,7 @@ impl Actor {
             relay_map,
             stun_sock_v4,
             stun_sock_v6,
+            quic_config,
             self.dns_resolver.clone(),
         );
 
@@ -975,7 +1002,7 @@ mod tests {
         // Note that the ProbePlan will change with each iteration.
         for i in 0..5 {
             println!("--round {}", i);
-            let r = client.get_report(dm.clone(), None, None).await?;
+            let r = client.get_report(dm.clone(), None, None, None).await?;
 
             assert!(r.udp, "want UDP");
             assert_eq!(
@@ -1016,7 +1043,7 @@ mod tests {
         let resolver = crate::dns::tests::resolver();
         let mut client = Client::new(None, resolver.clone())?;
 
-        let r = client.get_report(dm, None, None).await?;
+        let r = client.get_report(dm, None, None, None).await?;
         let mut r: Report = (*r).clone();
         r.portmap_probe = None;
 
@@ -1285,7 +1312,7 @@ mod tests {
             )
         };
 
-        let r = client.get_report(dm, Some(sock), None).await?;
+        let r = client.get_report(dm, Some(sock), None, None).await?;
         dbg!(&r);
         assert_eq!(r.hair_pinning, Some(true));