feat(autonatv2): Implement autonat v2

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "core",
     "examples/autonat",
+    "examples/autonatv2",
     "examples/browser-webrtc",
     "examples/chat",
     "examples/dcutr",
@@ -75,9 +76,9 @@ asynchronous-codec = { version = "0.7.0" }
 futures-bounded = { version = "0.2.3" }
 libp2p = { version = "0.54.0", path = "libp2p" }
 libp2p-allow-block-list = { version = "0.3.0", path = "misc/allow-block-list" }
-libp2p-autonat = { version = "0.12.0", path = "protocols/autonat" }
+libp2p-autonat = { version = "0.13.0", path = "protocols/autonat" }
 libp2p-connection-limits = { version = "0.3.1", path = "misc/connection-limits" }
-libp2p-core = { version = "0.41.2", path = "core" }
+libp2p-core = { version = "0.42.0", path = "core" }
 libp2p-dcutr = { version = "0.11.0", path = "protocols/dcutr" }
 libp2p-dns = { version = "0.41.1", path = "transports/dns" }
 libp2p-floodsub = { version = "0.44.0", path = "protocols/floodsub" }
@@ -89,7 +90,6 @@ libp2p-mdns = { version = "0.45.1", path = "protocols/mdns" }
 libp2p-memory-connection-limits = { version = "0.2.0", path = "misc/memory-connection-limits" }
 libp2p-metrics = { version = "0.14.1", path = "misc/metrics" }
 libp2p-mplex = { version = "0.41.0", path = "muxers/mplex" }
-libp2p-muxer-test-harness = { path = "muxers/test-harness" }
 libp2p-noise = { version = "0.44.0", path = "transports/noise" }
 libp2p-perf = { version = "0.3.0", path = "protocols/perf" }
 libp2p-ping = { version = "0.44.1", path = "protocols/ping" }

core/Cargo.toml

@@ -3,7 +3,7 @@ name = "libp2p-core"
 edition = "2021"
 rust-version = { workspace = true }
 description = "Core traits and structs of libp2p"
-version = "0.41.2"
+version = "0.42.0"
 authors = ["Parity Technologies <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

core/src/connection.rs

@@ -18,7 +18,10 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::multiaddr::{Multiaddr, Protocol};
+use crate::{
+    multiaddr::{Multiaddr, Protocol},
+    transport::PortUse,
+};
 
 /// The endpoint roles associated with a peer-to-peer communication channel.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -80,6 +83,13 @@ pub enum ConnectedPoint {
         ///   connection as a dialer and one peer dial the other and upgrade the
         ///   connection _as a listener_ overriding its role.
         role_override: Endpoint,
+        /// Whether the port for the outgoing connection was reused from a listener
+        /// or a new port was allocated. This is useful for address translation.
+        ///
+        /// The port use is implemented on a best-effort basis. It is not guaranteed
+        /// that [`PortUse::Reuse`] actually reused a port. A good example is the case
+        /// where there is no listener available to reuse a port from.
+        port_use: PortUse,
     },
     /// We received the node.
     Listener {
@@ -133,6 +143,7 @@ impl ConnectedPoint {
             ConnectedPoint::Dialer {
                 address,
                 role_override: _,
+                port_use: _,
             } => address,
             ConnectedPoint::Listener { local_addr, .. } => local_addr,
         }

core/src/either.rs

@@ -19,6 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::muxing::StreamMuxerEvent;
+use crate::transport::DialOpts;
 use crate::{
     muxing::StreamMuxer,
     transport::{ListenerId, Transport, TransportError, TransportEvent},
@@ -172,37 +173,19 @@ where
         }
     }
 
-    fn dial(&mut self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
-        use TransportError::*;
-        match self {
-            Either::Left(a) => match a.dial(addr) {
-                Ok(connec) => Ok(EitherFuture::First(connec)),
-                Err(MultiaddrNotSupported(addr)) => Err(MultiaddrNotSupported(addr)),
-                Err(Other(err)) => Err(Other(Either::Left(err))),
-            },
-            Either::Right(b) => match b.dial(addr) {
-                Ok(connec) => Ok(EitherFuture::Second(connec)),
-                Err(MultiaddrNotSupported(addr)) => Err(MultiaddrNotSupported(addr)),
-                Err(Other(err)) => Err(Other(Either::Right(err))),
-            },
-        }
-    }
-
-    fn dial_as_listener(
+    fn dial(
         &mut self,
         addr: Multiaddr,
-    ) -> Result<Self::Dial, TransportError<Self::Error>>
-    where
-        Self: Sized,
-    {
+        opts: DialOpts,
+    ) -> Result<Self::Dial, TransportError<Self::Error>> {
         use TransportError::*;
         match self {
-            Either::Left(a) => match a.dial_as_listener(addr) {
+            Either::Left(a) => match a.dial(addr, opts) {
                 Ok(connec) => Ok(EitherFuture::First(connec)),
                 Err(MultiaddrNotSupported(addr)) => Err(MultiaddrNotSupported(addr)),
                 Err(Other(err)) => Err(Other(Either::Left(err))),
             },
-            Either::Right(b) => match b.dial_as_listener(addr) {
+            Either::Right(b) => match b.dial(addr, opts) {
                 Ok(connec) => Ok(EitherFuture::Second(connec)),
                 Err(MultiaddrNotSupported(addr)) => Err(MultiaddrNotSupported(addr)),
                 Err(Other(err)) => Err(Other(Either::Right(err))),

core/src/transport.rs

@@ -48,7 +48,7 @@ pub mod upgrade;
 mod boxed;
 mod optional;
 
-use crate::ConnectedPoint;
+use crate::{ConnectedPoint, Endpoint};
 
 pub use self::boxed::Boxed;
 pub use self::choice::OrTransport;
@@ -58,6 +58,30 @@ pub use self::upgrade::Upgrade;
 
 static NEXT_LISTENER_ID: AtomicUsize = AtomicUsize::new(1);
 
+/// The port use policy for a new connection.
+#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, Hash)]
+pub enum PortUse {
+    /// Always allocate a new port for the dial.
+    New,
+    /// Best effor reusing of an existing port.
+    ///
+    /// If there is no listener present that can be used to dial, a new port is allocated.
+    #[default]
+    Reuse,
+}
+
+/// Options to customize the behaviour during dialing.
+#[derive(Debug, Copy, Clone)]
+pub struct DialOpts {
+    /// The endpoint establishing a new connection.
+    ///
+    /// When attempting a hole-punch, both parties simultaneously "dial" each other but one party has to be the "listener" on the final connection.
+    /// This option specifies the role of this node in the final connection.
+    pub role: Endpoint,
+    /// The port use policy for a new connection.
+    pub port_use: PortUse,
+}
+
 /// A transport provides connection-oriented communication between two peers
 /// through ordered streams of data (i.e. connections).
 ///
@@ -129,16 +153,10 @@ pub trait Transport {
     ///
     /// If [`TransportError::MultiaddrNotSupported`] is returned, it may be desirable to
     /// try an alternative [`Transport`], if available.
-    fn dial(&mut self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>>;
-
-    /// As [`Transport::dial`] but has the local node act as a listener on the outgoing connection.
-    ///
-    /// This option is needed for NAT and firewall hole punching.
-    ///
-    /// See [`ConnectedPoint::Dialer`] for related option.
-    fn dial_as_listener(
+    fn dial(
         &mut self,
         addr: Multiaddr,
+        opts: DialOpts,
     ) -> Result<Self::Dial, TransportError<Self::Error>>;
 
     /// Poll for [`TransportEvent`]s.

core/src/transport/and_then.rs

@@ -19,8 +19,8 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::{
-    connection::{ConnectedPoint, Endpoint},
-    transport::{ListenerId, Transport, TransportError, TransportEvent},
+    connection::ConnectedPoint,
+    transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent},
 };
 use either::Either;
 use futures::prelude::*;
@@ -68,40 +68,23 @@ where
         self.transport.remove_listener(id)
     }
 
-    fn dial(&mut self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
-        let dialed_fut = self
-            .transport
-            .dial(addr.clone())
-            .map_err(|err| err.map(Either::Left))?;
-        let future = AndThenFuture {
-            inner: Either::Left(Box::pin(dialed_fut)),
-            args: Some((
-                self.fun.clone(),
-                ConnectedPoint::Dialer {
-                    address: addr,
-                    role_override: Endpoint::Dialer,
-                },
-            )),
-            _marker: PhantomPinned,
-        };
-        Ok(future)
-    }
-
-    fn dial_as_listener(
+    fn dial(
         &mut self,
         addr: Multiaddr,
+        opts: DialOpts,
     ) -> Result<Self::Dial, TransportError<Self::Error>> {
         let dialed_fut = self
             .transport
-            .dial_as_listener(addr.clone())
+            .dial(addr.clone(), opts)
             .map_err(|err| err.map(Either::Left))?;
         let future = AndThenFuture {
             inner: Either::Left(Box::pin(dialed_fut)),
             args: Some((
                 self.fun.clone(),
                 ConnectedPoint::Dialer {
                     address: addr,
-                    role_override: Endpoint::Listener,
+                    role_override: opts.role,
+                    port_use: opts.port_use,
                 },
             )),
             _marker: PhantomPinned,

core/src/transport/boxed.rs

@@ -18,7 +18,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::transport::{ListenerId, Transport, TransportError, TransportEvent};
+use crate::transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent};
 use futures::{prelude::*, stream::FusedStream};
 use multiaddr::Multiaddr;
 use std::{
@@ -58,8 +58,11 @@ trait Abstract<O> {
         addr: Multiaddr,
     ) -> Result<(), TransportError<io::Error>>;
     fn remove_listener(&mut self, id: ListenerId) -> bool;
-    fn dial(&mut self, addr: Multiaddr) -> Result<Dial<O>, TransportError<io::Error>>;
-    fn dial_as_listener(&mut self, addr: Multiaddr) -> Result<Dial<O>, TransportError<io::Error>>;
+    fn dial(
+        &mut self,
+        addr: Multiaddr,
+        opts: DialOpts,
+    ) -> Result<Dial<O>, TransportError<io::Error>>;
     fn address_translation(&self, server: &Multiaddr, observed: &Multiaddr) -> Option<Multiaddr>;
     fn poll(
         self: Pin<&mut Self>,
@@ -86,15 +89,12 @@ where
         Transport::remove_listener(self, id)
     }
 
-    fn dial(&mut self, addr: Multiaddr) -> Result<Dial<O>, TransportError<io::Error>> {
-        let fut = Transport::dial(self, addr)
-            .map(|r| r.map_err(box_err))
-            .map_err(|e| e.map(box_err))?;
-        Ok(Box::pin(fut) as Dial<_>)
-    }
-
-    fn dial_as_listener(&mut self, addr: Multiaddr) -> Result<Dial<O>, TransportError<io::Error>> {
-        let fut = Transport::dial_as_listener(self, addr)
+    fn dial(
+        &mut self,
+        addr: Multiaddr,
+        opts: DialOpts,
+    ) -> Result<Dial<O>, TransportError<io::Error>> {
+        let fut = Transport::dial(self, addr, opts)
             .map(|r| r.map_err(box_err))
             .map_err(|e| e.map(box_err))?;
         Ok(Box::pin(fut) as Dial<_>)
@@ -143,15 +143,12 @@ impl<O> Transport for Boxed<O> {
         self.inner.remove_listener(id)
     }
 
-    fn dial(&mut self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
-        self.inner.dial(addr)
-    }
-
-    fn dial_as_listener(
+    fn dial(
         &mut self,
         addr: Multiaddr,
+        opts: DialOpts,
     ) -> Result<Self::Dial, TransportError<Self::Error>> {
-        self.inner.dial_as_listener(addr)
+        self.inner.dial(addr, opts)
     }
 
     fn address_translation(&self, server: &Multiaddr, observed: &Multiaddr) -> Option<Multiaddr> {

core/src/transport/choice.rs

@@ -19,7 +19,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 use crate::either::EitherFuture;
-use crate::transport::{ListenerId, Transport, TransportError, TransportEvent};
+use crate::transport::{DialOpts, ListenerId, Transport, TransportError, TransportEvent};
 use either::Either;
 use futures::future;
 use multiaddr::Multiaddr;
@@ -92,19 +92,23 @@ where
         self.0.remove_listener(id) || self.1.remove_listener(id)
     }
 
-    fn dial(&mut self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
+    fn dial(
+        &mut self,
+        addr: Multiaddr,
+        opts: DialOpts,
+    ) -> Result<Self::Dial, TransportError<Self::Error>> {
         tracing::trace!(
             address=%addr,
-            "Attempting to dial address using {}",
+            "Attempting to dial using {}",
             std::any::type_name::<A>()
         );
-        let addr = match self.0.dial(addr) {
+        let addr = match self.0.dial(addr, opts) {
             Ok(connec) => return Ok(EitherFuture::First(connec)),
             Err(TransportError::MultiaddrNotSupported(addr)) => {
                 tracing::debug!(
                     address=%addr,
-                    "Failed to dial address using {}",
-                    std::any::type_name::<A>()
+                    "Failed to dial using {}",
+                    std::any::type_name::<B>(),
                 );
                 addr
             }
@@ -115,16 +119,16 @@ where
 
         tracing::trace!(
             address=%addr,
-            "Attempting to dial address using {}",
+            "Attempting to dial {}",
             std::any::type_name::<A>()
         );
-        let addr = match self.1.dial(addr) {
+        let addr = match self.1.dial(addr, opts) {
             Ok(connec) => return Ok(EitherFuture::Second(connec)),
             Err(TransportError::MultiaddrNotSupported(addr)) => {
                 tracing::debug!(
                     address=%addr,
-                    "Failed to dial address using {}",
-                    std::any::type_name::<A>()
+                    "Failed to dial using {}",
+                    std::any::type_name::<B>(),
                 );
                 addr
             }
@@ -136,29 +140,6 @@ where
         Err(TransportError::MultiaddrNotSupported(addr))
     }
 
-    fn dial_as_listener(
-        &mut self,
-        addr: Multiaddr,
-    ) -> Result<Self::Dial, TransportError<Self::Error>> {
-        let addr = match self.0.dial_as_listener(addr) {
-            Ok(connec) => return Ok(EitherFuture::First(connec)),
-            Err(TransportError::MultiaddrNotSupported(addr)) => addr,
-            Err(TransportError::Other(err)) => {
-                return Err(TransportError::Other(Either::Left(err)))
-            }
-        };
-
-        let addr = match self.1.dial_as_listener(addr) {
-            Ok(connec) => return Ok(EitherFuture::Second(connec)),
-            Err(TransportError::MultiaddrNotSupported(addr)) => addr,
-            Err(TransportError::Other(err)) => {
-                return Err(TransportError::Other(Either::Right(err)))
-            }
-        };
-
-        Err(TransportError::MultiaddrNotSupported(addr))
-    }
-
     fn address_translation(&self, server: &Multiaddr, observed: &Multiaddr) -> Option<Multiaddr> {
         if let Some(addr) = self.0.address_translation(server, observed) {
             Some(addr)