wip

dignifiedquire · dignifiedquire · commit db712c03d1f9 · 2025-07-18T16:39:34.000+02:00
diff --git a/iroh/src/endpoint.rs b/iroh/src/endpoint.rs
@@ -45,7 +45,7 @@ use crate::{
     magicsock::{self, Handle, NodeIdMappedAddr, OwnAddressSnafu},
     metrics::EndpointMetrics,
     net_report::Report,
-    tls,
+    tls, RelayProtocol,
 };
 
 mod rtt_actor;
@@ -732,13 +732,12 @@ impl Endpoint {
             self.add_node_addr(node_addr.clone())?;
         }
         let node_id = node_addr.node_id;
-        let relay_url = node_addr.relay_url.clone();
 
         // Get the mapped IPv6 address from the magic socket. Quinn will connect to this
         // address.  Start discovery for this node if it's enabled and we have no valid or
         // verified address information for this node.  Dropping the discovery cancels any
         // still running task.
-        let (mapped_addr, direct_addresses, _discovery_drop_guard) = self
+        let (mapped_addr, _discovery_drop_guard) = self
             .get_mapping_addr_and_maybe_start_discovery(node_addr)
             .await
             .context(NoAddressSnafu)?;
@@ -750,12 +749,7 @@ impl Endpoint {
         // Start connecting via quinn. This will time out after 10 seconds if no reachable
         // address is available.
 
-        debug!(
-            ?mapped_addr,
-            ?direct_addresses,
-            ?relay_url,
-            "Attempting connection..."
-        );
+        debug!(?mapped_addr, "Attempting connection...");
         let client_config = {
             let mut alpn_protocols = vec![alpn.to_vec()];
             alpn_protocols.extend(options.additional_alpns);
@@ -768,27 +762,18 @@ impl Endpoint {
             client_config
         };
 
-        // TODO: race available addresses, this is currently only using the relay addr to connect
-        let dest_addr = if relay_url.is_none() && !direct_addresses.is_empty() {
-            direct_addresses[0]
-        } else {
-            mapped_addr.private_socket_addr()
-        };
+        let dest_addr = mapped_addr.private_socket_addr();
         let server_name = &tls::name::encode(node_id);
         let connect = self
             .msock
             .endpoint()
             .connect_with(client_config, dest_addr, server_name)
             .context(QuinnSnafu)?;
 
-        let mut paths = direct_addresses;
-        paths.push(mapped_addr.private_socket_addr());
-
         Ok(Connecting {
             inner: connect,
             ep: self.clone(),
             remote_node_id: Some(node_id),
-            paths,
             _discovery_drop_guard,
         })
     }
@@ -1383,20 +1368,18 @@ impl Endpoint {
     async fn get_mapping_addr_and_maybe_start_discovery(
         &self,
         node_addr: NodeAddr,
-    ) -> Result<(NodeIdMappedAddr, Vec<SocketAddr>, Option<DiscoveryTask>), GetMappingAddressError>
-    {
+    ) -> Result<(NodeIdMappedAddr, Option<DiscoveryTask>), GetMappingAddressError> {
         let node_id = node_addr.node_id;
 
         // Only return a mapped addr if we have some way of dialing this node, in other
         // words, we have either a relay URL or at least one direct address.
         let addr = if self.msock.has_send_address(node_id) {
-            let maddr = self.msock.get_mapping_addr(node_id);
-            maddr.map(|maddr| (maddr, self.msock.get_direct_addrs(node_id)))
+            self.msock.get_mapping_addr(node_id)
         } else {
             None
         };
         match addr {
-            Some((maddr, direct)) => {
+            Some(maddr) => {
                 // We have some way of dialing this node, but that doesn't actually mean
                 // we can actually connect to any of these addresses.
                 // Therefore, we will invoke the discovery service if we haven't received from the
@@ -1408,7 +1391,7 @@ impl Endpoint {
                 let discovery = DiscoveryTask::maybe_start_after_delay(self, node_id, delay)
                     .ok()
                     .flatten();
-                Ok((maddr, direct, discovery))
+                Ok((maddr, discovery))
             }
 
             None => {
@@ -1423,8 +1406,7 @@ impl Endpoint {
                     .await
                     .context(get_mapping_address_error::DiscoverSnafu)?;
                 if let Some(addr) = self.msock.get_mapping_addr(node_id) {
-                    let direct = self.msock.get_direct_addrs(node_id);
-                    Ok((addr, direct, Some(discovery)))
+                    Ok((addr, Some(discovery)))
                 } else {
                     Err(get_mapping_address_error::NoAddressSnafu.build())
                 }
@@ -1653,8 +1635,6 @@ pub struct Connecting {
     inner: quinn::Connecting,
     ep: Endpoint,
     remote_node_id: Option<NodeId>,
-    /// Additional paths to open once a connection is created
-    paths: Vec<SocketAddr>,
     /// We run discovery as long as we haven't established a connection yet.
     #[debug("Option<DiscoveryTask>")]
     _discovery_drop_guard: Option<DiscoveryTask>,
@@ -1783,21 +1763,15 @@ impl Future for Connecting {
                 if let Some(remote) = *this.remote_node_id {
                     let weak_handle = conn.inner.weak_handle();
                     let path_events = conn.inner.path_events();
-                    this.ep.msock.register_connection(
-                        remote,
-                        weak_handle,
-                        path_events,
-                        this.paths.clone(),
-                    );
+                    this.ep
+                        .msock
+                        .register_connection(remote, weak_handle, path_events);
                 } else if let Ok(remote) = conn.remote_node_id() {
                     let weak_handle = conn.inner.weak_handle();
                     let path_events = conn.inner.path_events();
-                    this.ep.msock.register_connection(
-                        remote,
-                        weak_handle,
-                        path_events,
-                        this.paths.clone(),
-                    );
+                    this.ep
+                        .msock
+                        .register_connection(remote, weak_handle, path_events);
                 } else {
                     warn!("unable to determine node id for the remote");
                 }
@@ -2284,6 +2258,7 @@ mod tests {
     };
 
     use iroh_base::{NodeAddr, NodeId, SecretKey};
+    use iroh_relay::http::Protocol;
     use n0_future::{task::AbortOnDropHandle, StreamExt};
     use n0_snafu::{Error, Result, ResultExt};
     use n0_watcher::Watcher;
diff --git a/iroh/src/magicsock.rs b/iroh/src/magicsock.rs
@@ -45,6 +45,7 @@ use netwatch::{ip::LocalAddresses, UdpSocket};
 use quinn::{AsyncUdpSocket, ServerConfig, WeakConnectionHandle};
 use quinn_proto::PathEvent;
 use rand::Rng;
+use relay_mapped_addrs::RelayMappedAddresses;
 use smallvec::SmallVec;
 use snafu::{ResultExt, Snafu};
 use tokio::sync::{mpsc, Mutex as AsyncMutex};
@@ -79,6 +80,7 @@ use crate::{
 
 mod metrics;
 mod node_map;
+mod relay_mapped_addrs;
 
 pub(crate) mod transports;
 
@@ -200,6 +202,8 @@ pub(crate) struct MagicSock {
 
     /// Tracks the mapped IP addresses
     ip_mapped_addrs: IpMappedAddresses,
+    /// Tracks the mapped IP addresses
+    relay_mapped_addrs: RelayMappedAddresses,
     /// Local addresses
     local_addrs_watch: LocalAddrsWatch,
     /// Currently bound IP addresses of all sockets
@@ -295,25 +299,10 @@ impl MagicSock {
         remote: NodeId,
         conn: WeakConnectionHandle,
         mut path_events: tokio::sync::broadcast::Receiver<PathEvent>,
-        paths: Vec<SocketAddr>,
     ) {
         self.connection_map.insert(remote, conn);
-        task::spawn(async move {
-            let conn = conn.clone();
-            for addr in paths {
-                match conn.open_path(addr, quinn_proto::PathStatus::Backup).await {
-                    Ok(path) => {
-                        path.set_max_idle_timeout(Some(ENDPOINTS_FRESH_ENOUGH_DURATION))
-                            .ok();
-                        path.set_keep_alive_interval(Some(HEARTBEAT_INTERVAL)).ok();
-                    }
-                    Err(err) => {
-                        warn!("failed to open path {:?}", err);
-                    }
-                }
-            }
-        });
 
+        // TODO: open additional paths
         // TODO: track task
         // TODO: find a good home for this
         task::spawn(async move {
@@ -461,6 +450,11 @@ impl MagicSock {
             self.node_map
                 .add_node_addr(addr.clone(), source, &self.metrics.magicsock);
 
+            if let Some(url) = addr.relay_url() {
+                self.relay_mapped_addrs
+                    .get_or_register(url.clone(), addr.node_id);
+            }
+
             // Add paths to the existing connections
             self.add_paths(addr);
 
@@ -633,11 +627,8 @@ impl MagicSock {
 
         let mut active_paths = SmallVec::<[_; 3]>::new();
 
-        match MappedAddr::from(transmit.destination) {
-            MappedAddr::None(addr) => {
-                active_paths.push(transports::Addr::from(addr));
-            }
-            MappedAddr::NodeId(dest) => {
+        match MultipathMappedAddr::from(transmit.destination) {
+            MultipathMappedAddr::Mixed(dest) => {
                 trace!(
                     dst = %dest,
                     src = ?transmit.src_ip,
@@ -670,7 +661,10 @@ impl MagicSock {
                 }
             }
             #[cfg(not(wasm_browser))]
-            MappedAddr::Ip(dest) => {
+            MultipathMappedAddr::Ip(addr) => {
+                active_paths.push(transports::Addr::Ip(addr));
+            }
+            MultipathMappedAddr::Relay(dest) => {
                 trace!(
                     dst = %dest,
                     src = ?transmit.src_ip,
@@ -680,9 +674,9 @@ impl MagicSock {
 
                 // Check if this is a known IpMappedAddr, and if so, send over UDP
                 // Get the socket addr
-                match self.ip_mapped_addrs.get_ip_addr(&dest) {
-                    Some(addr) => {
-                        active_paths.push(transports::Addr::from(addr));
+                match self.relay_mapped_addrs.get_url(&dest) {
+                    Some((relay, node_id)) => {
+                        active_paths.push(transports::Addr::Relay(relay, node_id));
                     }
                     None => {
                         error!(%dest, "unknown mapped address");
@@ -1103,33 +1097,7 @@ impl From<SocketAddr> for MultipathMappedAddr {
                 if let Ok(ip_mapped_addr) = IpMappedAddr::try_from(addr) {
                     return Self::Relay(ip_mapped_addr);
                 }
-                MappedAddr::Self(value)
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-enum MappedAddr {
-    NodeId(NodeIdMappedAddr),
-    #[cfg(not(wasm_browser))]
-    Ip(IpMappedAddr),
-    None(SocketAddr),
-}
-
-impl From<SocketAddr> for MappedAddr {
-    fn from(value: SocketAddr) -> Self {
-        match value.ip() {
-            IpAddr::V4(_) => MappedAddr::None(value),
-            IpAddr::V6(addr) => {
-                if let Ok(node_id_mapped_addr) = NodeIdMappedAddr::try_from(addr) {
-                    return MappedAddr::NodeId(node_id_mapped_addr);
-                }
-                #[cfg(not(wasm_browser))]
-                if let Ok(ip_mapped_addr) = IpMappedAddr::try_from(addr) {
-                    return MappedAddr::Ip(ip_mapped_addr);
-                }
-                MappedAddr::None(value)
+                Self::Ip(value)
             }
         }
     }
@@ -1315,6 +1283,7 @@ impl Handle {
             bind_ip(addr_v4, addr_v6, &metrics).context(BindSocketsSnafu)?;
 
         let ip_mapped_addrs = IpMappedAddresses::default();
+        let relay_mapped_addrs = RelayMappedAddresses::default();
 
         let (actor_sender, actor_receiver) = mpsc::channel(256);
 
@@ -1362,6 +1331,7 @@ impl Handle {
             node_map,
             connection_map: Default::default(),
             ip_mapped_addrs: ip_mapped_addrs.clone(),
+            relay_mapped_addrs,
             discovery,
             discovery_user_data: RwLock::new(discovery_user_data),
             direct_addrs: Default::default(),
diff --git a/iroh/src/magicsock/relay_mapped_addrs.rs b/iroh/src/magicsock/relay_mapped_addrs.rs
@@ -0,0 +1,54 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use iroh_base::{NodeId, RelayUrl};
+use snafu::Snafu;
+
+use crate::net_report::IpMappedAddr;
+
+/// Can occur when converting a [`SocketAddr`] to an [`RelayMappedAddr`]
+#[derive(Debug, Snafu)]
+#[snafu(display("Failed to convert"))]
+pub struct RelayMappedAddrError;
+
+/// A Map of [`RelayMappedAddresses`] to [`SocketAddr`].
+#[derive(Debug, Clone, Default)]
+pub(crate) struct RelayMappedAddresses(Arc<std::sync::Mutex<Inner>>);
+
+#[derive(Debug, Default)]
+pub(super) struct Inner {
+    by_mapped_addr: BTreeMap<IpMappedAddr, (RelayUrl, NodeId)>,
+    by_url: BTreeMap<(RelayUrl, NodeId), IpMappedAddr>,
+}
+
+impl RelayMappedAddresses {
+    /// Adds a [`RelayUrl`] to the map and returns the generated [`IpMappedAddr`].
+    ///
+    /// If this [`RelayUrl`] already exists in the map, it returns its
+    /// associated [`IpMappedAddr`].
+    ///
+    /// Otherwise a new [`IpMappedAddr`] is generated for it and returned.
+    pub(super) fn get_or_register(&self, relay: RelayUrl, node: NodeId) -> IpMappedAddr {
+        let mut inner = self.0.lock().expect("poisoned");
+        if let Some(mapped_addr) = inner.by_url.get(&(relay.clone(), node)) {
+            return *mapped_addr;
+        }
+        let ip_mapped_addr = IpMappedAddr::generate();
+        inner
+            .by_mapped_addr
+            .insert(ip_mapped_addr, (relay.clone(), node));
+        inner.by_url.insert((relay, node), ip_mapped_addr);
+        ip_mapped_addr
+    }
+
+    /// Returns the [`IpMappedAddr`] for the given [`RelayUrl`].
+    pub(crate) fn get_mapped_addr(&self, relay: RelayUrl, node: NodeId) -> Option<IpMappedAddr> {
+        let inner = self.0.lock().expect("poisoned");
+        inner.by_url.get(&(relay, node)).copied()
+    }
+
+    /// Returns the [`RelayUrl`] for the given [`IpMappedAddr`].
+    pub(crate) fn get_url(&self, mapped_addr: &IpMappedAddr) -> Option<(RelayUrl, NodeId)> {
+        let inner = self.0.lock().expect("poisoned");
+        inner.by_mapped_addr.get(mapped_addr).cloned()
+    }
+}
diff --git a/iroh/src/magicsock/transports/relay.rs b/iroh/src/magicsock/transports/relay.rs
@@ -106,7 +106,7 @@ impl RelayTransport {
                 .segment_size
                 .map_or(dm.datagrams.contents.len(), |s| s as usize);
             meta_out.ecn = None;
-            meta_out.dst_ip = None; // TODO: insert the relay url for this relay
+            meta_out.dst_ip = None;
 
             *addr = (dm.url, dm.src).into();
             num_msgs += 1;
diff --git a/iroh/src/net_report/ip_mapped_addrs.rs b/iroh/src/net_report/ip_mapped_addrs.rs
@@ -38,7 +38,7 @@ impl IpMappedAddr {
     ///
     /// This generates a new IPv6 address in the Unique Local Address range (RFC 4193)
     /// which is recognised by iroh as an IP mapped address.
-    pub(super) fn generate() -> Self {
+    pub(crate) fn generate() -> Self {
         let mut addr = [0u8; 16];
         addr[0] = Self::ADDR_PREFIXL;
         addr[1..6].copy_from_slice(&Self::ADDR_GLOBAL_ID);
