open additional paths after the initial connection

Author: dignifiedquire

Cargo.lock

@@ -1811,15 +1811,9 @@ impl Connection {
 
         // Grab the remote identity and register this connection
         if let Some(remote) = remote_id {
-            let weak_handle = conn.inner.weak_handle();
-            let path_events = conn.inner.path_events();
-            ep.msock
-                .register_connection(remote, weak_handle, path_events);
+            ep.msock.register_connection(remote, &conn.inner);
         } else if let Ok(remote) = conn.remote_node_id() {
-            let weak_handle = conn.inner.weak_handle();
-            let path_events = conn.inner.path_events();
-            ep.msock
-                .register_connection(remote, weak_handle, path_events);
+            ep.msock.register_connection(remote, &conn.inner);
         } else {
             warn!("unable to determine node id for the remote");
         }

iroh/src/endpoint.rs

@@ -43,7 +43,6 @@ use netwatch::netmon;
 #[cfg(not(wasm_browser))]
 use netwatch::{ip::LocalAddresses, UdpSocket};
 use quinn::{AsyncUdpSocket, ServerConfig, WeakConnectionHandle};
-use quinn_proto::PathEvent;
 use rand::Rng;
 use relay_mapped_addrs::{IpMappedAddr, RelayMappedAddresses};
 use smallvec::SmallVec;
@@ -292,18 +291,14 @@ impl MagicSock {
         self.local_addrs_watch.get().expect("disconnected")
     }
 
-    pub(crate) fn register_connection(
-        &self,
-        remote: NodeId,
-        conn: WeakConnectionHandle,
-        mut path_events: tokio::sync::broadcast::Receiver<PathEvent>,
-    ) {
-        self.connection_map.insert(remote, conn);
+    pub(crate) fn register_connection(&self, remote: NodeId, conn: &quinn::Connection) {
+        let weak_handle = conn.weak_handle();
+        self.connection_map.insert(remote, weak_handle);
 
-        // TODO: open additional paths
         // TODO: track task
         // TODO: find a good home for this
-        task::spawn(async move {
+        let mut path_events = conn.path_events();
+        let _task = task::spawn(async move {
             loop {
                 match path_events.recv().await {
                     Ok(event) => {
@@ -316,6 +311,11 @@ impl MagicSock {
                 }
             }
         });
+
+        // open additional paths
+        if let Some(addr) = self.node_map.get_current_addr(remote) {
+            self.add_paths(addr);
+        }
     }
 
     #[cfg(not(wasm_browser))]

iroh/src/magicsock.rs

@@ -189,6 +189,14 @@ impl NodeMap {
             .unwrap_or_default()
     }
 
+    pub(super) fn get_current_addr(&self, node_key: NodeId) -> Option<NodeAddr> {
+        self.inner
+            .lock()
+            .expect("poisoned")
+            .get(NodeStateKey::NodeId(node_key))
+            .map(|ep| ep.get_current_addr())
+    }
+
     pub(super) fn handle_call_me_maybe(
         &self,
         sender: PublicKey,

iroh/src/magicsock/node_map.rs

@@ -647,6 +647,17 @@ impl NodeState {
         (udp_addr, relay_url, ping_msgs)
     }
 
+    pub(crate) fn get_current_addr(&self) -> NodeAddr {
+        // TODO: more selective?
+        let mut node_addr =
+            NodeAddr::new(self.node_id).with_direct_addresses(self.udp_paths.addrs());
+        if let Some((url, _)) = &self.relay_url {
+            node_addr = node_addr.with_relay_url(url.clone());
+        }
+
+        node_addr
+    }
+
     /// Get the direct addresses for this endpoint.
     pub(super) fn direct_addresses(&self) -> impl Iterator<Item = IpPort> + '_ {
         self.udp_paths.paths.keys().copied()

iroh/src/magicsock/node_map/node_state.rs

@@ -88,6 +88,9 @@ impl NodeUdpPaths {
             chosen_candidate: None,
         }
     }
+    pub(super) fn addrs(&self) -> Vec<SocketAddr> {
+        self.paths.keys().map(|ip| (*ip).into()).collect()
+    }
 
     /// Returns the current UDP address to send on.
     ///