fix(quic): add support for reusing an existing socket for local dialing

transports/quic/src/transport.rs

@@ -155,9 +155,14 @@ impl<P: Provider> GenTransport<P> {
                 if l.is_closed {
                     return false;
                 }
-                let listen_addr = l.socket_addr();
-                SocketFamily::is_same(&listen_addr.ip(), &socket_addr.ip())
-                    && listen_addr.ip().is_loopback() == socket_addr.ip().is_loopback()
+                SocketFamily::is_same(&l.socket_addr().ip(), &socket_addr.ip())
+            })
+            .filter(|l| {
+                if socket_addr.ip().is_loopback() {
+                    l.supports_loopback
+                } else {
+                    true
+                }
             })
             .collect();
         match listeners.len() {
@@ -428,6 +433,9 @@ struct Listener<P: Provider> {
 
     /// The stream must be awaken after it has been closed to deliver the last event.
     close_listener_waker: Option<Waker>,
+
+    /// `true` if a listener supports loopback interface
+    supports_loopback: bool,
 }
 
 impl<P: Provider> Listener<P> {
@@ -440,13 +448,17 @@ impl<P: Provider> Listener<P> {
     ) -> Result<Self, Error> {
         let if_watcher;
         let pending_event;
+        let mut supports_loopback = false;
         let local_addr = socket.local_addr()?;
         if local_addr.ip().is_unspecified() {
             if_watcher = Some(P::new_if_watcher()?);
             pending_event = None;
         } else {
             if_watcher = None;
             let ma = socketaddr_to_multiaddr(&local_addr, version);
+            if local_addr.ip().is_loopback() {
+                supports_loopback = true
+            }
             pending_event = Some(TransportEvent::NewAddress {
                 listener_id,
                 listen_addr: ma,
@@ -467,6 +479,7 @@ impl<P: Provider> Listener<P> {
             is_closed: false,
             pending_event,
             close_listener_waker: None,
+            supports_loopback,
         })
     }
 
@@ -513,7 +526,10 @@ impl<P: Provider> Listener<P> {
                     if let Some(listen_addr) =
                         ip_to_listenaddr(&endpoint_addr, inet.addr(), self.version)
                     {
-                        log::debug!("New listen address: {}", listen_addr);
+                        log::debug!("New listen address: {listen_addr}");
+                        if inet.addr().is_loopback() {
+                            self.supports_loopback = true;
+                        }
                         return Poll::Ready(TransportEvent::NewAddress {
                             listener_id: self.listener_id,
                             listen_addr,
@@ -524,7 +540,7 @@ impl<P: Provider> Listener<P> {
                     if let Some(listen_addr) =
                         ip_to_listenaddr(&endpoint_addr, inet.addr(), self.version)
                     {
-                        log::debug!("Expired listen address: {}", listen_addr);
+                        log::debug!("Expired listen address: {listen_addr}");
                         return Poll::Ready(TransportEvent::AddressExpired {
                             listener_id: self.listener_id,
                             listen_addr,
@@ -730,7 +746,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};
 

transports/quic/tests/smoke.rs

@@ -414,6 +414,49 @@ async fn write_after_peer_dropped_stream() {
     stream_b.close().await.expect("Close failed.");
 }
 
+/// - 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
+#[cfg(feature = "tokio")]
+#[tokio::test]
+async fn test_local_listener_reuse() {
+    let (_, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
+    let (_, mut b_transport) = create_default_transport::<quic::tokio::Provider>();
+
+    a_transport
+        .listen_on(
+            ListenerId::next(),
+            "/ip4/0.0.0.0/udp/0/quic-v1".parse().unwrap(),
+        )
+        .unwrap();
+
+    // wait until a listener reports a loopback address
+    let a_addr = 'outer: loop {
+        let ev = a_transport.next().await.unwrap();
+        let listen_addr = ev.into_new_address().unwrap();
+        for proto in listen_addr.iter() {
+            if let Protocol::Ip4(ip4) = proto {
+                if ip4.is_loopback() {
+                    break 'outer listen_addr;
+                }
+            }
+        }
+    };
+    // If we do not poll until the end, `NewAddress` events may be `Ready` and `connect` function
+    // below will panic due to an unexpected event.
+    poll_fn(|cx| {
+        let mut pinned = Pin::new(&mut a_transport);
+        while let Poll::Ready(e) = pinned.as_mut().poll(cx) {}
+        Poll::Ready(())
+    })
+    .await;
+
+    let b_addr = start_listening(&mut b_transport, "/ip4/127.0.0.1/udp/0/quic-v1").await;
+    let (_, send_back_addr, _) = connect(&mut b_transport, &mut a_transport, b_addr).await.0;
+    assert_eq!(send_back_addr, a_addr);
+}
+
 async fn smoke<P: Provider>() {
     let _ = env_logger::try_init();