Add test

transports/quic/src/transport.rs

@@ -729,7 +729,7 @@ fn socketaddr_to_multiaddr(socket_addr: &SocketAddr, version: ProtocolVersion) -
 
 #[cfg(test)]
 #[cfg(any(feature = "async-std", feature = "tokio"))]
-mod test {
+mod tests {
     use futures::future::poll_fn;
     use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
@@ -904,4 +904,86 @@ mod test {
             .unwrap();
         assert!(!transport.dialer.contains_key(&SocketFamily::Ipv4));
     }
+
+    /// - A listens on 0.0.0.0:0
+    /// - B listens on 127.0.0.1:0
+    /// - A dials B
+    /// - Source port of A at B is the A's listen port
+    #[allow(non_snake_case)]
+    #[cfg(feature = "tokio")]
+    #[tokio::test]
+    async fn test_local_listener_reuse() {
+        let keypair = libp2p_identity::Keypair::generate_ed25519();
+        let mut node_A = crate::tokio::Transport::new(Config::new(&keypair));
+
+        let keypair = libp2p_identity::Keypair::generate_ed25519();
+        let mut node_B = crate::tokio::Transport::new(Config::new(&keypair));
+
+        node_B
+            .listen_on(
+                ListenerId::next(),
+                "/ip4/127.0.0.1/udp/0/quic-v1".try_into().unwrap(),
+            )
+            .unwrap();
+
+        node_A
+            .listen_on(
+                ListenerId::next(),
+                "/ip4/0.0.0.0/udp/0/quic-v1".try_into().unwrap(),
+            )
+            .unwrap();
+
+        // node_A: wait until a listener reports a loopback address
+        poll_fn(|cx| {
+            let mut pinned = Pin::new(&mut node_A);
+            while let Poll::Ready(ev) = pinned.as_mut().poll(cx) {
+                if let TransportEvent::NewAddress { listen_addr, .. } = ev {
+                    if multiaddr_to_socketaddr(&listen_addr, false)
+                        .unwrap()
+                        .0
+                        .ip()
+                        .is_loopback()
+                    {
+                        return Poll::Ready(());
+                    }
+                }
+            }
+
+            Poll::Pending
+        })
+        .await;
+
+        let listener_addr = |node: &GenTransport<_>| {
+            node.listeners
+                .iter()
+                .next()
+                .unwrap()
+                .socket
+                .local_addr()
+                .unwrap()
+        };
+
+        let node_B_multiaddr =
+            socketaddr_to_multiaddr(&listener_addr(&node_B), ProtocolVersion::V1);
+
+        // node A dials node B
+        node_A.dial(node_B_multiaddr).unwrap().await.unwrap();
+
+        // Verify that node B received node A listening port
+        poll_fn(|cx| {
+            let mut pinned = Pin::new(&mut node_B);
+            while let Poll::Ready(e) = pinned.as_mut().poll(cx) {
+                // node B received connection incoming from node A
+                if let TransportEvent::Incoming { send_back_addr, .. } = e {
+                    let (socket_addr, ..) =
+                        multiaddr_to_socketaddr(&send_back_addr, false).unwrap();
+                    let node_A_listener_port = listener_addr(&node_A).port();
+                    assert_eq!(socket_addr.port(), node_A_listener_port);
+                    return Poll::Ready(());
+                }
+            }
+            Poll::Pending
+        })
+        .await;
+    }
 }