TCP/AutoNAT/Identify

safenode/Cargo.toml

@@ -36,7 +36,7 @@ futures = "~0.3.13"
 hex = "~0.4.3"
 itertools = "~0.10.1"
 lazy_static = "~1.4.0"
-libp2p = { version="0.51", features = ["tokio", "dns", "kad", "macros", "mdns", "quic", "request-response", "identify"] }
+libp2p = { version="0.51", features = ["tokio", "dns", "kad", "macros", "mdns", "quic", "request-response", "identify", "autonat", "mplex", "noise", "tcp", "yamux"] }
 libp2p-quic = { version = "0.7.0-alpha.3", features = ["tokio"] }
 opentelemetry = { version = "0.17", features = ["rt-tokio"], optional = true }
 opentelemetry-otlp = { version = "0.10", optional = true }

safenode/src/bin/safenode/main.rs

@@ -81,6 +81,15 @@ struct Opt {
     /// Enable the admin/ctrl RPC service by providing an IP and port for it to listen on.
     #[clap(long)]
     rpc: Option<SocketAddr>,
+
+    /// Assume we are running on a local network and enable mDNS peer discovery.
+    /// Defaults to false, which means we will only connect to peers specified by `--peer`.
+    #[clap(long)]
+    local: bool,
+
+    /// Specify external address, to advertise on the network.
+    #[clap(long)]
+    external_address: Option<SocketAddr>,
 }
 
 #[derive(Debug)]
@@ -132,6 +141,8 @@ fn main() -> Result<()> {
             node_socket_addr,
             peers.clone(),
             opt.rpc,
+            opt.local,
+            opt.external_address,
             &log_dir,
             &root_dir,
         ))?;
@@ -145,13 +156,16 @@ async fn start_node(
     node_socket_addr: SocketAddr,
     peers: Vec<(PeerId, Multiaddr)>,
     rpc: Option<SocketAddr>,
+    local: bool,
+    external_address: Option<SocketAddr>,
     log_dir: &str,
     root_dir: &Path,
 ) -> Result<()> {
     let started_instant = std::time::Instant::now();
 
     info!("Starting node ...");
-    let running_node = Node::run(node_socket_addr, peers, root_dir).await?;
+    let running_node =
+        Node::run(node_socket_addr, peers, root_dir, local, external_address).await?;
 
     // Channel to receive node ctrl cmds from RPC service (if enabled), and events monitoring task
     let (ctrl_tx, mut ctrl_rx) = mpsc::channel::<NodeCtrl>(5);

safenode/src/client/api.rs

@@ -34,7 +34,8 @@ impl Client {
     /// Instantiate a new client.
     pub async fn new(signer: SecretKey, peers: Option<Vec<(PeerId, Multiaddr)>>) -> Result<Self> {
         info!("Starting Kad swarm in client mode...");
-        let (network, mut network_event_receiver, swarm_driver) = SwarmDriver::new_client()?;
+        let (network, mut network_event_receiver, swarm_driver) =
+            SwarmDriver::new_client(peers.is_none())?;
         info!("Client constructed network and swarm_driver");
         let events_channel = ClientEventsChannel::default();
         let client = Self {

safenode/src/network/event.rs

@@ -13,18 +13,20 @@ use super::{
 };
 use crate::{
     domain::storage::DiskBackedRecordStore,
-    network::IDENTIFY_AGENT_STR,
+    network::{IDENTIFY_AGENT_STR, multiaddr_strip_p2p, multiaddr_is_global},
     protocol::{
         messages::{QueryResponse, Request, Response},
         storage::Chunk,
     },
 };
+use itertools::Itertools;
 use libp2p::{
+    autonat,
     kad::{GetRecordOk, Kademlia, KademliaEvent, QueryResult, K_VALUE},
     mdns,
     multiaddr::Protocol,
     request_response::{self, ResponseChannel as PeerResponseChannel},
-    swarm::{NetworkBehaviour, SwarmEvent},
+    swarm::{behaviour::toggle::Toggle, NetworkBehaviour, SwarmEvent},
     Multiaddr, PeerId,
 };
 use std::collections::{hash_map, HashSet};
@@ -36,8 +38,9 @@ use tracing::{info, warn};
 pub(super) struct NodeBehaviour {
     pub(super) request_response: request_response::Behaviour<MsgCodec>,
     pub(super) kademlia: Kademlia<DiskBackedRecordStore>,
-    pub(super) mdns: mdns::tokio::Behaviour,
+    pub(super) mdns: Toggle<mdns::tokio::Behaviour>,
     pub(super) identify: libp2p::identify::Behaviour,
+    pub(super) autonat: Toggle<autonat::Behaviour>,
 }
 
 #[derive(Debug)]
@@ -46,6 +49,7 @@ pub(super) enum NodeEvent {
     Kademlia(KademliaEvent),
     Mdns(Box<mdns::Event>),
     Identify(Box<libp2p::identify::Event>),
+    Autonat(autonat::Event),
 }
 
 impl From<request_response::Event<Request, Response>> for NodeEvent {
@@ -72,6 +76,12 @@ impl From<libp2p::identify::Event> for NodeEvent {
     }
 }
 
+impl From<autonat::Event> for NodeEvent {
+    fn from(event: autonat::Event) -> Self {
+        NodeEvent::Autonat(event)
+    }
+}
+
 #[derive(Debug)]
 /// Channel to send the `Response` through.
 pub enum MsgResponder {
@@ -193,12 +203,30 @@ impl SwarmDriver {
                 }
             },
             SwarmEvent::Behaviour(NodeEvent::Identify(iden)) => {
-                info!("IdentifyEvent: {iden:?}");
                 match *iden {
                     libp2p::identify::Event::Received { peer_id, info } => {
-                        info!("Adding peer to routing table, based on received identify info from {peer_id:?}: {info:?}");
+                        info!(%peer_id, ?info, "identify: received info");
                         if info.agent_version.starts_with(IDENTIFY_AGENT_STR) {
-                            for multiaddr in info.listen_addrs {
+                            let addrs = match self.local {
+                                true => info.listen_addrs,
+                                // If we're not in local mode, only add globally reachable addresses
+                                false => info
+                                    .listen_addrs
+                                    .into_iter()
+                                    .filter(multiaddr_is_global)
+                                    .collect()
+                                ,
+                            };
+                            // Strip the `/p2p/...` part of the multiaddresses
+                            let addrs: Vec<_> = addrs
+                                .into_iter()
+                                .map(|addr| multiaddr_strip_p2p(&addr))
+                                // And deduplicate the list
+                                .unique()
+                                    .collect();
+
+                            info!(%peer_id, ?addrs, "identify: adding addresses");
+                            for multiaddr in addrs {
                                 let _routing_update = self
                                     .swarm
                                     .behaviour_mut()
@@ -207,9 +235,9 @@ impl SwarmDriver {
                             }
                         }
                     }
-                    libp2p::identify::Event::Sent { .. } => {}
-                    libp2p::identify::Event::Pushed { .. } => {}
-                    libp2p::identify::Event::Error { .. } => {}
+                    libp2p::identify::Event::Sent { .. } => info!("identify: {iden:?}"),
+                    libp2p::identify::Event::Pushed { .. } => info!("identify: {iden:?}"),
+                    libp2p::identify::Event::Error { .. } => info!("identify: {iden:?}"),
                 }
             }
             SwarmEvent::Behaviour(NodeEvent::Mdns(mdns_event)) => match *mdns_event {
@@ -274,6 +302,13 @@ impl SwarmDriver {
             }
             SwarmEvent::IncomingConnectionError { .. } => {}
             SwarmEvent::Dialing(peer_id) => info!("Dialing {peer_id}"),
+            SwarmEvent::Behaviour(NodeEvent::Autonat(event)) => match event {
+                autonat::Event::InboundProbe(e) => trace!("AutoNAT inbound probe: {e:?}"),
+                autonat::Event::OutboundProbe(e) => trace!("AutoNAT outbound probe: {e:?}"),
+                autonat::Event::StatusChanged { old, new } => {
+                    info!("AutoNAT status changed: {old:?} -> {new:?}");
+                }
+            },
             todo => error!("SwarmEvent has not been implemented: {todo:?}"),
         }
         Ok(())