Add PeerId to NewExternalAddrOfPeer

protocols/autonat/src/behaviour.rs

@@ -589,7 +589,10 @@ impl NetworkBehaviour for Behaviour {
                 self.inner.on_swarm_event(listener_closed)
             }
             confirmed @ FromSwarm::ExternalAddrConfirmed(_) => self.inner.on_swarm_event(confirmed),
-            FromSwarm::NewExternalAddrOfPeer(NewExternalAddrOfPeer { addr }) => {
+            FromSwarm::NewExternalAddrOfPeer(NewExternalAddrOfPeer {
+                addr: _addr,
+                peer_id: _peer_id,
+            }) => {
                 todo!();
             }
         }

protocols/kad/src/behaviour.rs

@@ -44,8 +44,8 @@ use libp2p_swarm::behaviour::{
 use libp2p_swarm::{
     dial_opts::{self, DialOpts},
     ConnectionDenied, ConnectionId, DialError, ExternalAddresses, ListenAddresses,
-    NetworkBehaviour, NotifyHandler, PollParameters, StreamProtocol, THandler, THandlerInEvent,
-    THandlerOutEvent, ToSwarm,
+    NetworkBehaviour, NewExternalAddrOfPeer, NotifyHandler, PollParameters, StreamProtocol,
+    THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
 };
 use log::{debug, info, warn};
 use smallvec::SmallVec;
@@ -1993,6 +1993,38 @@ where
         }
     }
 
+    fn on_new_address_event(
+        &mut self,
+        NewExternalAddrOfPeer { addr, peer_id }: NewExternalAddrOfPeer,
+    ) {
+        let key = kbucket::Key::from(peer_id.clone());
+
+        match self.kbuckets.entry(&key) {
+            kbucket::Entry::Present(mut entry, _node_status) => {
+                if entry.value().insert(addr.clone()) {
+                    self.queued_events.push_back(ToSwarm::GenerateEvent(
+                        KademliaEvent::RoutingUpdated {
+                            peer: *peer_id,
+                            is_new_peer: false,
+                            addresses: entry.value().clone(),
+                            old_peer: None,
+                            bucket_range: self
+                                .kbuckets
+                                .bucket(&key)
+                                .map(|b| b.range())
+                                .expect("Not kbucket::Entry::SelfEntry."),
+                        },
+                    ))
+                }
+            }
+            kbucket::Entry::Pending(mut entry, _node_status) => {
+                entry.value().insert(addr.clone());
+                ()
+            }
+            kbucket::Entry::Absent(_) | kbucket::Entry::SelfEntry => {}
+        }
+    }
+
     fn on_dial_failure(&mut self, DialFailure { peer_id, error, .. }: DialFailure) {
         let peer_id = match peer_id {
             Some(id) => id,
@@ -2551,7 +2583,7 @@ where
             }
             FromSwarm::DialFailure(dial_failure) => self.on_dial_failure(dial_failure),
             FromSwarm::AddressChange(address_change) => self.on_address_change(address_change),
-            FromSwarm::NewExternalAddrOfPeer(_addr) => todo!(),
+            FromSwarm::NewExternalAddrOfPeer(addr) => self.on_new_address_event(addr),
             FromSwarm::ExpiredListenAddr(_)
             | FromSwarm::NewExternalAddrCandidate(_)
             | FromSwarm::NewListenAddr(_)

swarm-derive/src/lib.rs

@@ -474,12 +474,12 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
             .map(|(field_n, field)| match field.ident {
                 Some(ref i) => quote! {
                 self.#i.on_swarm_event(#from_swarm::NewExternalAddrOfPeer(#new_external_addr_of_peer {
-                        addr,
+                        addr, peer_id
                     }));
                 },
                 None => quote! {
                 self.#field_n.on_swarm_event(#from_swarm::NewExternalAddrOfPeer(#new_external_addr_of_peer {
-                        addr,
+                        addr, peer_id
                     }));
                 },
             })
@@ -779,8 +779,8 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                 std::task::Poll::Ready(#network_behaviour_action::CloseConnection { peer_id, connection }) => {
                     return std::task::Poll::Ready(#network_behaviour_action::CloseConnection { peer_id, connection });
                 }
-                std::task::Poll::Ready(#network_behaviour_action::NewExternalAddrOfPeer(addr)) => {
-                    return std::task::Poll::Ready(#network_behaviour_action::NewExternalAddrOfPeer(addr));
+                std::task::Poll::Ready(#network_behaviour_action::NewExternalAddrOfPeer{addr, peer_id}) => {
+                    return std::task::Poll::Ready(#network_behaviour_action::NewExternalAddrOfPeer{addr, peer_id});
                 }
                 std::task::Poll::Pending => {},
             }
@@ -909,7 +909,7 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> syn::Result<Toke
                         #listener_closed { listener_id, reason })
                     => { #(#on_listener_closed_stmts)* }
                     #from_swarm::NewExternalAddrOfPeer(
-                        #new_external_addr_of_peer {addr})
+                        #new_external_addr_of_peer {addr, peer_id})
                     => { #(#on_new_external_addr_of_peer_stmts)* }
                     _ => {}
                 }

swarm/src/behaviour.rs

@@ -323,7 +323,7 @@ pub enum ToSwarm<TOutEvent, TInEvent> {
 
     /// TODO: more documentation needed
     /// Reports external address of a remote peer to other `NetworkBehaviours`
-    NewExternalAddrOfPeer(Multiaddr),
+    NewExternalAddrOfPeer { addr: Multiaddr, peer_id: PeerId },
 }
 
 impl<TOutEvent, TInEventOld> ToSwarm<TOutEvent, TInEventOld> {
@@ -356,7 +356,9 @@ impl<TOutEvent, TInEventOld> ToSwarm<TOutEvent, TInEventOld> {
             ToSwarm::NewExternalAddrCandidate(addr) => ToSwarm::NewExternalAddrCandidate(addr),
             ToSwarm::ExternalAddrConfirmed(addr) => ToSwarm::ExternalAddrConfirmed(addr),
             ToSwarm::ExternalAddrExpired(addr) => ToSwarm::ExternalAddrExpired(addr),
-            ToSwarm::NewExternalAddrOfPeer(addr) => ToSwarm::NewExternalAddrOfPeer(addr),
+            ToSwarm::NewExternalAddrOfPeer { addr, peer_id } => {
+                ToSwarm::NewExternalAddrOfPeer { addr, peer_id }
+            }
         }
     }
 }
@@ -388,7 +390,9 @@ impl<TOutEvent, THandlerIn> ToSwarm<TOutEvent, THandlerIn> {
                 peer_id,
                 connection,
             },
-            ToSwarm::NewExternalAddrOfPeer(addr) => ToSwarm::NewExternalAddrOfPeer(addr),
+            ToSwarm::NewExternalAddrOfPeer { addr, peer_id } => {
+                ToSwarm::NewExternalAddrOfPeer { addr, peer_id }
+            }
         }
     }
 }
@@ -570,9 +574,10 @@ pub struct ExternalAddrExpired<'a> {
 }
 
 /// [`FromSwarm`] variant that informs the behaviour that a new external address was detected.
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub struct NewExternalAddrOfPeer<'a> {
     pub addr: &'a Multiaddr,
+    pub peer_id: &'a PeerId,
 }
 
 impl<'a, Handler> FromSwarm<'a, Handler> {

swarm/src/lib.rs

@@ -111,8 +111,8 @@ pub mod derive_prelude {
 pub use behaviour::{
     AddressChange, CloseConnection, ConnectionClosed, DialFailure, ExpiredListenAddr,
     ExternalAddrExpired, ExternalAddresses, FromSwarm, ListenAddresses, ListenFailure,
-    ListenerClosed, ListenerError, NetworkBehaviour, NewExternalAddrCandidate, NewListenAddr,
-    NotifyHandler, PollParameters, ToSwarm,
+    ListenerClosed, ListenerError, NetworkBehaviour, NewExternalAddrCandidate,
+    NewExternalAddrOfPeer, NewListenAddr, NotifyHandler, PollParameters, ToSwarm,
 };
 pub use connection::pool::ConnectionCounters;
 pub use connection::{ConnectionError, ConnectionId, SupportedProtocols};
@@ -1113,36 +1113,12 @@ where
                     self.pool.disconnect(peer_id);
                 }
             },
-            ToSwarm::NewExternalAddrOfPeer(addr) => {
-                log::debug!("ToSwarm::NewExternalAddrOfPeer");
-
-                let translated_addresses = {
-                    let mut addrs: Vec<_> = self
-                        .listened_addrs
-                        .values()
-                        .flatten()
-                        .filter_map(|server| self.transport.address_translation(server, &addr))
-                        .collect();
-
-                    // remove duplicates
-                    addrs.sort_unstable();
-                    addrs.dedup();
-                    addrs
-                };
-
-                if translated_addresses.is_empty() {
-                    self.behaviour
-                        .on_swarm_event(FromSwarm::NewExternalAddrCandidate(
-                            NewExternalAddrCandidate { addr: &addr },
-                        ));
-                } else {
-                    for addr in translated_addresses {
-                        self.behaviour
-                            .on_swarm_event(FromSwarm::NewExternalAddrCandidate(
-                                NewExternalAddrCandidate { addr: &addr },
-                            ));
-                    }
-                }
+            ToSwarm::NewExternalAddrOfPeer { addr, peer_id } => {
+                self.behaviour
+                    .on_swarm_event(FromSwarm::NewExternalAddrOfPeer(NewExternalAddrOfPeer {
+                        addr: &addr,
+                        peer_id: &peer_id,
+                    }))
             }
         }
 
@@ -1612,9 +1588,9 @@ impl fmt::Display for DialError {
                 f,
                 "Dial error: tried to dial local peer id at {endpoint:?}."
             ),
-            DialError::DialPeerConditionFalse(PeerCondition::Disconnected) => write!(f, "Dial error: dial condition was configured to only happen when disconnected (`PeerCondition::Disconnected`), but node is already connected, thus cancelling new dial."),
-            DialError::DialPeerConditionFalse(PeerCondition::NotDialing) => write!(f, "Dial error: dial condition was configured to only happen if there is currently no ongoing dialing attempt (`PeerCondition::NotDialing`), but a dial is in progress, thus cancelling new dial."),
-            DialError::DialPeerConditionFalse(PeerCondition::Always) => unreachable!("Dial peer condition is by definition true."),
+            DialError::DialPeerConditionFalse(c) => {
+                write!(f, "Dial error: condition {c:?} for dialing peer was false.")
+            }
             DialError::Aborted => write!(
                 f,
                 "Dial error: Pending connection attempt has been aborted."