From a08c430100edfba7b924c957f98294fd79de0e1b Mon Sep 17 00:00:00 2001
From: tv <tv@krebsco.de>
Date: Sat, 31 Oct 2026 20:52:27 +0100
Subject: libp2p: ignored ranges aren't told

---
 src/transport/libp2p/ignore.rs | 101 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 100 insertions(+), 1 deletion(-)

(limited to 'src/transport/libp2p/ignore.rs')

diff --git a/src/transport/libp2p/ignore.rs b/src/transport/libp2p/ignore.rs
index b14235e..659ec91 100644
--- a/src/transport/libp2p/ignore.rs
+++ b/src/transport/libp2p/ignore.rs
@@ -1,5 +1,6 @@
 //! `--libp2p-ignore`: address ranges neither published nor dialled, nor connected over
-//! (`Ignoring`, a behaviour that denies connections there).
+//! (`Ignoring`, a behaviour that denies connections there), nor told peers by identify
+//! (`Identifying`).
 
 use super::*;
 
@@ -144,3 +145,101 @@ impl ::libp2p::swarm::NetworkBehaviour for Ignoring {
         std::task::Poll::Pending
     }
 }
+
+/// libp2p's identify, not told our listen addresses in the ranges `libp2p-ignore` names:
+/// peers would remember them, show them, and dial them in vain.
+pub(super) struct Identifying {
+    pub(super) inner: ::libp2p::identify::Behaviour,
+    pub(super) ranges: Vec<IpRange>,
+}
+
+impl ::libp2p::swarm::NetworkBehaviour for Identifying {
+    type ConnectionHandler =
+        <::libp2p::identify::Behaviour as ::libp2p::swarm::NetworkBehaviour>::ConnectionHandler;
+    type ToSwarm = ::libp2p::identify::Event;
+
+    fn handle_pending_inbound_connection(
+        &mut self,
+        connection_id: ConnectionId,
+        local_addr: &Multiaddr,
+        remote_addr: &Multiaddr,
+    ) -> Result<(), ::libp2p::swarm::ConnectionDenied> {
+        self.inner
+            .handle_pending_inbound_connection(connection_id, local_addr, remote_addr)
+    }
+
+    fn handle_established_inbound_connection(
+        &mut self,
+        connection_id: ConnectionId,
+        peer: PeerId,
+        local_addr: &Multiaddr,
+        remote_addr: &Multiaddr,
+    ) -> Result<::libp2p::swarm::THandler<Self>, ::libp2p::swarm::ConnectionDenied> {
+        self.inner.handle_established_inbound_connection(
+            connection_id,
+            peer,
+            local_addr,
+            remote_addr,
+        )
+    }
+
+    fn handle_pending_outbound_connection(
+        &mut self,
+        connection_id: ConnectionId,
+        maybe_peer: Option<PeerId>,
+        addresses: &[Multiaddr],
+        effective_role: ::libp2p::core::Endpoint,
+    ) -> Result<Vec<Multiaddr>, ::libp2p::swarm::ConnectionDenied> {
+        self.inner.handle_pending_outbound_connection(
+            connection_id,
+            maybe_peer,
+            addresses,
+            effective_role,
+        )
+    }
+
+    fn handle_established_outbound_connection(
+        &mut self,
+        connection_id: ConnectionId,
+        peer: PeerId,
+        addr: &Multiaddr,
+        role_override: ::libp2p::core::Endpoint,
+        port_use: ::libp2p::core::transport::PortUse,
+    ) -> Result<::libp2p::swarm::THandler<Self>, ::libp2p::swarm::ConnectionDenied> {
+        self.inner.handle_established_outbound_connection(
+            connection_id,
+            peer,
+            addr,
+            role_override,
+            port_use,
+        )
+    }
+
+    fn on_swarm_event(&mut self, event: ::libp2p::swarm::FromSwarm) {
+        use ::libp2p::swarm::FromSwarm;
+        match event {
+            FromSwarm::NewListenAddr(new) if ignored(&self.ranges, new.addr) => {}
+            FromSwarm::ExpiredListenAddr(expired) if ignored(&self.ranges, expired.addr) => {}
+            _ => self.inner.on_swarm_event(event),
+        }
+    }
+
+    fn on_connection_handler_event(
+        &mut self,
+        peer_id: PeerId,
+        connection_id: ConnectionId,
+        event: ::libp2p::swarm::THandlerOutEvent<Self>,
+    ) {
+        self.inner
+            .on_connection_handler_event(peer_id, connection_id, event)
+    }
+
+    fn poll(
+        &mut self,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<
+        ::libp2p::swarm::ToSwarm<Self::ToSwarm, ::libp2p::swarm::THandlerInEvent<Self>>,
+    > {
+        self.inner.poll(cx)
+    }
+}
-- 
cgit v1.3.1