Merge branch 'master' into haiko-webrtc-outbound-multistream-nego-fix

Author: haikoschol

CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
+## [0.12.2] - 2025-11-28
+
+This release allows all Bitswap CIDs (v1) to pass regardless of the used hash. It also enhances local address checks in the transport manager.
+
+### Changed
+
+- transport-service: Enhance logging with protocol names  ([#485](https://github.com/paritytech/litep2p/pull/485))
+- bitswap: Reexports for CID  ([#486](https://github.com/paritytech/litep2p/pull/486))
+- Allow all the Bitswap CIDs (v1) to pass regardless of used hash  ([#482](https://github.com/paritytech/litep2p/pull/482))
+- transport/manager: Enhance local address checks  ([#480](https://github.com/paritytech/litep2p/pull/480))
+
 ## [0.12.1] - 2025-11-21
 
 This release adds support for connecting to multiple Kademlia DHT networks. The change is backward-compatible, no client code modifications should be needed compared to v0.12.0.

Cargo.lock

@@ -3,7 +3,7 @@ name = "litep2p"
 description = "Peer-to-peer networking library"
 repository = "https://github.com/paritytech/litep2p"
 license = "MIT"
-version = "0.12.1"
+version = "0.12.2"
 edition = "2021"
 
 # cargo-machete does not detect serde_millis usage, so we ignore the warning

Cargo.toml

@@ -28,18 +28,15 @@ use crate::{
     PeerId,
 };
 
-use cid::Version;
-use multihash::Code;
+use cid::{Cid, Version};
 use prost::Message;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tokio_stream::{StreamExt, StreamMap};
 
-use std::{collections::HashMap, time::Duration};
-
-pub use cid::Cid;
 pub use config::Config;
 pub use handle::{BitswapCommand, BitswapEvent, BitswapHandle, ResponseType};
 pub use schema::bitswap::{wantlist::WantType, BlockPresenceType};
+use std::{collections::HashMap, time::Duration};
 
 mod config;
 mod handle;
@@ -167,10 +164,7 @@ impl Bitswap {
                     _ => return None,
                 };
 
-                (cid.version() == cid::Version::V1
-                    && cid.hash().code() == u64::from(Code::Blake2b256)
-                    && cid.hash().size() == 32)
-                    .then_some((cid, want_type))
+                Some((cid, want_type))
             })
             .collect::<Vec<_>>();
 

src/protocol/libp2p/bitswap/mod.rs

@@ -339,10 +339,11 @@ impl TransportService {
         tracing::debug!(
             target: LOG_TARGET,
             ?peer,
-            protocol = %self.protocol,
             ?endpoint,
             ?connection_id,
-            "connection established",
+            protocol = %self.protocol,
+            current_state = ?self.connections.get(&peer),
+            "on connection established",
         );
 
         match self.connections.get_mut(&peer) {
@@ -353,19 +354,38 @@ impl TransportService {
                         ?peer,
                         ?connection_id,
                         ?endpoint,
+                        protocol = %self.protocol,
                         "ignoring third connection",
                     );
                     None
                 }
                 None => {
                     self.keep_alive_tracker.on_connection_established(peer, connection_id);
 
+                    tracing::trace!(
+                        target: LOG_TARGET,
+                        ?peer,
+                        ?endpoint,
+                        ?connection_id,
+                        protocol = %self.protocol,
+                        "secondary connection established",
+                    );
+
                     context.secondary = Some(handle);
 
                     None
                 }
             },
             None => {
+                tracing::trace!(
+                    target: LOG_TARGET,
+                    ?peer,
+                    ?endpoint,
+                    ?connection_id,
+                    protocol = %self.protocol,
+                    "primary connection established",
+                );
+
                 self.connections.insert(peer, ConnectionContext::new(handle));
 
                 self.keep_alive_tracker.on_connection_established(peer, connection_id);
@@ -381,13 +401,23 @@ impl TransportService {
         peer: PeerId,
         connection_id: ConnectionId,
     ) -> Option<TransportEvent> {
+        tracing::debug!(
+            target: LOG_TARGET,
+            ?peer,
+            ?connection_id,
+            protocol = %self.protocol,
+            current_state = ?self.connections.get(&peer),
+            "on connection closed",
+        );
+
         self.keep_alive_tracker.on_connection_closed(peer, connection_id);
 
         let Some(context) = self.connections.get_mut(&peer) else {
             tracing::warn!(
                 target: LOG_TARGET,
                 ?peer,
                 ?connection_id,
+                protocol = %self.protocol,
                 "connection closed to a non-existent peer",
             );
 
@@ -398,7 +428,13 @@ impl TransportService {
         // if the primary connection was closed, check if there exist a secondary connection
         // and if it does, convert the secondary connection a primary connection
         if context.primary.connection_id() == &connection_id {
-            tracing::trace!(target: LOG_TARGET, ?peer, ?connection_id, "primary connection closed");
+            tracing::trace!(
+                target: LOG_TARGET,
+                ?peer,
+                ?connection_id,
+                protocol = %self.protocol,
+                "primary connection closed"
+            );
 
             match context.secondary.take() {
                 None => {
@@ -410,6 +446,7 @@ impl TransportService {
                         target: LOG_TARGET,
                         ?peer,
                         ?connection_id,
+                        protocol = %self.protocol,
                         "switch to secondary connection",
                     );
 
@@ -425,6 +462,7 @@ impl TransportService {
                     target: LOG_TARGET,
                     ?peer,
                     ?connection_id,
+                    protocol = %self.protocol,
                     "secondary connection closed",
                 );
 
@@ -436,6 +474,7 @@ impl TransportService {
                     ?peer,
                     ?connection_id,
                     ?connection_state,
+                    protocol = %self.protocol,
                     "connection closed but it doesn't exist",
                 );
 
@@ -448,6 +487,13 @@ impl TransportService {
     ///
     /// Call fails if `Litep2p` doesn't have a known address for the peer.
     pub fn dial(&mut self, peer: &PeerId) -> Result<(), ImmediateDialError> {
+        tracing::trace!(
+            target: LOG_TARGET,
+            ?peer,
+            protocol = %self.protocol,
+            "Dial peer requested",
+        );
+
         self.transport_handle.dial(peer)
     }
 
@@ -460,6 +506,13 @@ impl TransportService {
     /// since `Litep2p` internally keeps track of all peer addresses it has learned through user
     /// calling this function, Kademlia peer discoveries and `Identify` responses.
     pub fn dial_address(&mut self, address: Multiaddr) -> Result<(), ImmediateDialError> {
+        tracing::trace!(
+            target: LOG_TARGET,
+            ?address,
+            protocol = %self.protocol,
+            "Dial address requested",
+        );
+
         self.transport_handle.dial_address(address)
     }
 

src/protocol/transport_service.rs

@@ -40,6 +40,7 @@ use tokio::sync::mpsc::{error::TrySendError, Sender};
 
 use std::{
     collections::{HashMap, HashSet},
+    net::IpAddr,
     sync::{
         atomic::{AtomicUsize, Ordering},
         Arc,
@@ -164,14 +165,66 @@ impl TransportManagerHandle {
         }
     }
 
+    /// Helper to extract IP and Port from a Multiaddr
+    fn extract_ip_port(addr: &Multiaddr) -> Option<(IpAddr, u16)> {
+        let mut iter = addr.iter();
+        let ip = match iter.next() {
+            Some(Protocol::Ip4(i)) => IpAddr::V4(i),
+            Some(Protocol::Ip6(i)) => IpAddr::V6(i),
+            _ => return None,
+        };
+
+        let port = match iter.next() {
+            Some(Protocol::Tcp(p)) | Some(Protocol::Udp(p)) => p,
+            _ => return None,
+        };
+
+        Some((ip, port))
+    }
+
     /// Check if the address is a local listen address and if so, discard it.
     fn is_local_address(&self, address: &Multiaddr) -> bool {
+        // Strip the peer ID if present.
         let address: Multiaddr = address
             .iter()
             .take_while(|protocol| !std::matches!(protocol, Protocol::P2p(_)))
             .collect();
 
-        self.listen_addresses.read().contains(&address)
+        // Check for the exact match.
+        let listen_addresses = self.listen_addresses.read();
+        if listen_addresses.contains(&address) {
+            return true;
+        }
+
+        let Some((ip, port)) = Self::extract_ip_port(&address) else {
+            return false;
+        };
+
+        for listen_address in listen_addresses.iter() {
+            let Some((listen_ip, listen_port)) = Self::extract_ip_port(listen_address) else {
+                continue;
+            };
+
+            if port == listen_port {
+                // Exact IP match.
+                if listen_ip == ip {
+                    return true;
+                }
+
+                // Check if the listener is binding to any (0.0.0.0) interface
+                // and the incoming is a loopback address.
+                if listen_ip.is_unspecified() && ip.is_loopback() {
+                    return true;
+                }
+
+                // Check for ipv4/ipv6 loopback equivalence.
+                if listen_ip.is_loopback() && ip.is_loopback() {
+                    return true;
+                }
+            }
+        }
+
+        false
     }
 
     /// Add one or more known addresses for peer.
@@ -745,11 +798,12 @@ mod tests {
         let (cmd_tx, _cmd_rx) = channel(64);
 
         let local_peer_id = PeerId::random();
-        let first_addr: Multiaddr = "/ip6/::1/tcp/8888".parse().expect("valid multiaddress");
-        let second_addr: Multiaddr = "/ip4/127.0.0.1/tcp/8888".parse().expect("valid multiaddress");
+        let specific_bind: Multiaddr = "/ip6/::1/tcp/8888".parse().expect("valid multiaddress");
+        let ipv6_bind: Multiaddr = "/ip4/127.0.0.1/tcp/8888".parse().expect("valid multiaddress");
+        let wildcard_bind: Multiaddr = "/ip4/0.0.0.0/tcp/9000".parse().unwrap();
 
         let listen_addresses = Arc::new(RwLock::new(
-            [first_addr.clone(), second_addr.clone()].iter().cloned().collect(),
+            [specific_bind, wildcard_bind, ipv6_bind].into_iter().collect(),
         ));
         println!("{:?}", listen_addresses);
 
@@ -762,12 +816,14 @@ mod tests {
             public_addresses: PublicAddresses::new(local_peer_id),
         };
 
-        // local addresses
+        // Exact matches
+        assert!(handle
+            .is_local_address(&"/ip4/127.0.0.1/tcp/8888".parse().expect("valid multiaddress")));
         assert!(handle.is_local_address(
             &"/ip6/::1/tcp/8888".parse::<Multiaddr>().expect("valid multiaddress")
         ));
-        assert!(handle
-            .is_local_address(&"/ip4/127.0.0.1/tcp/8888".parse().expect("valid multiaddress")));
+
+        // Peer ID stripping
         assert!(handle.is_local_address(
             &"/ip6/::1/tcp/8888/p2p/12D3KooWT2ouvz5uMmCvHJGzAGRHiqDts5hzXR7NdoQ27pGdzp9Q"
                 .parse()
@@ -778,7 +834,6 @@ mod tests {
                 .parse()
                 .expect("valid multiaddress")
         ));
-
         // same address but different peer id
         assert!(handle.is_local_address(
             &"/ip6/::1/tcp/8888/p2p/12D3KooWPGxxxQiBEBZ52RY31Z2chn4xsDrGCMouZ88izJrak2T1"
@@ -791,10 +846,29 @@ mod tests {
                 .expect("valid multiaddress")
         ));
 
-        // different address
+        // Port collision protection: we listen on 0.0.0.0:9000 and should match any loopback
+        // address on port 9000.
+        assert!(
+            handle.is_local_address(&"/ip4/127.0.0.1/tcp/9000".parse().unwrap()),
+            "Loopback input should satisfy Wildcard (0.0.0.0) listener"
+        );
+        // 8.8.8.8 is a different IP.
+        assert!(
+            !handle.is_local_address(&"/ip4/8.8.8.8/tcp/9000".parse().unwrap()),
+            "Remote IP with same port should NOT be considered local against Wildcard listener"
+        );
+
+        // Port mismatches
+        assert!(
+            !handle.is_local_address(&"/ip4/127.0.0.1/tcp/1234".parse().unwrap()),
+            "Same IP but different port should fail"
+        );
+        assert!(
+            !handle.is_local_address(&"/ip4/0.0.0.0/tcp/1234".parse().unwrap()),
+            "Wildcard IP but different port should fail"
+        );
         assert!(!handle
             .is_local_address(&"/ip4/127.0.0.1/tcp/9999".parse().expect("valid multiaddress")));
-        // different address
         assert!(!handle
             .is_local_address(&"/ip4/127.0.0.1/tcp/7777".parse().expect("valid multiaddress")));
     }

src/transport/manager/handle.rs

@@ -29,6 +29,9 @@ pub mod multiaddr {
 pub mod multihash {
     pub use multihash::{Code, Error, Multihash, MultihashDigest};
 }
+pub mod cid {
+    pub use cid::{multihash::Multihash, Cid, CidGeneric, Error, Result, Version};
+}
 
 pub mod protocol;