Bind to local addr based on network adapter

Author: DanglingPointer

mtorrent-core/src/trackers/http.rs

@@ -2,7 +2,7 @@ use local_async_utils::prelude::*;
 use mtorrent_utils::{benc, ip};
 use reqwest::{ClientBuilder, Url};
 use std::collections::{BTreeMap, HashMap};
-use std::net::SocketAddr;
+use std::net::{IpAddr, SocketAddr};
 use std::{fmt, io, str};
 use thiserror::Error;
 
@@ -60,10 +60,11 @@ fn set_interface(builder: ClientBuilder, interface: Option<&str>) -> ClientBuild
 }
 
 impl TrackerClient {
-    pub fn new(interface: Option<&str>) -> Result<Self, Error> {
+    pub fn new(local_addr: IpAddr, interface: Option<&str>) -> Result<Self, Error> {
         let builder = reqwest::Client::builder()
             .gzip(true)
             .user_agent(APP_USER_AGENT)
+            .local_address(local_addr)
             .timeout(sec!(30));
 
         let inner = set_interface(builder, interface).build()?;
@@ -417,6 +418,7 @@ fn dictionary_peers(data: &[benc::Element]) -> impl Iterator<Item = SocketAddr>
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::net::Ipv4Addr;
 
     #[test]
     fn test_announce_uri() {
@@ -529,7 +531,7 @@ mod tests {
     #[tokio::test]
     async fn test_https_scrape_and_announce() {
         let tracker_url = "https://torrent.ubuntu.com/announce";
-        let client = TrackerClient::new(Default::default()).unwrap();
+        let client = TrackerClient::new(Ipv4Addr::UNSPECIFIED.into(), None).unwrap();
 
         let request = TrackerRequestBuilder::try_from(tracker_url).unwrap();
         let response = client.scrape(request).await.unwrap_or_else(|e| panic!("Scrape error: {e}"));

mtorrent-core/src/trackers/mod.rs

@@ -4,7 +4,7 @@ mod url;
 
 use futures_util::TryFutureExt;
 use local_async_utils::sec;
-use mtorrent_utils::ip::bind_to_interface;
+use mtorrent_utils::ip;
 use mtorrent_utils::peer_id::PeerId;
 use std::collections::HashMap;
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
@@ -183,7 +183,10 @@ impl Manager {
             }};
         }
 
-        let http_client = http::TrackerClient::new(self.config.bind_interface.as_deref())
+        let interface = self.config.bind_interface.as_deref();
+        let local_ipv4 = ip::get_bind_addr_v4(interface);
+        let local_ipv6 = ip::get_bind_addr_v6(interface);
+        let http_client = http::TrackerClient::new(local_ipv4.into(), interface)
             .inspect_err(|e| log::error!("Failed to create HTTP tracker client: {e}"))
             .ok();
 
@@ -206,8 +209,14 @@ impl Manager {
                     TrackerUrl::Udp(addr) => {
                         let interface = self.config.bind_interface.clone();
                         spawn_child_task!(async move {
-                            let result =
-                                do_udp_announce(&addr, request.data, interface.as_deref()).await;
+                            let result = do_udp_announce(
+                                &addr,
+                                request.data,
+                                interface.as_deref(),
+                                local_ipv4,
+                                local_ipv6,
+                            )
+                            .await;
                             _ = request.responder.send(result).inspect_err(|_| {
                                 log::warn!("Failed to send back udp announce result")
                             });
@@ -231,8 +240,14 @@ impl Manager {
                     TrackerUrl::Udp(addr) => {
                         let interface = self.config.bind_interface.clone();
                         spawn_child_task!(async move {
-                            let result =
-                                do_udp_scrape(&addr, request.data, interface.as_deref()).await;
+                            let result = do_udp_scrape(
+                                &addr,
+                                request.data,
+                                interface.as_deref(),
+                                local_ipv4,
+                                local_ipv6,
+                            )
+                            .await;
                             _ = request.responder.send(result).inspect_err(|_| {
                                 log::warn!("Failed to send back udp scrape result")
                             });
@@ -318,6 +333,8 @@ async fn do_http_scrape(
 async fn new_udp_client(
     tracker_addr_str: &str,
     interface: Option<&str>,
+    local_ipv4: Ipv4Addr,
+    local_ipv6: Ipv6Addr,
 ) -> io::Result<udp::TrackerConnection> {
     async fn bind_and_connect_socket(
         bind_addr: &SocketAddr,
@@ -326,16 +343,16 @@ async fn new_udp_client(
     ) -> io::Result<UdpSocket> {
         let socket = UdpSocket::bind(bind_addr).await?;
         if let Some(iface) = interface {
-            bind_to_interface(&socket, iface)?;
+            ip::bind_to_interface(&socket, iface)?;
         }
         socket.connect(&remote_addr).await?;
         Ok(socket)
     }
 
     for tracker_addr in net::lookup_host(tracker_addr_str).await? {
         let local_ip = match &tracker_addr {
-            SocketAddr::V4(_) => Ipv4Addr::UNSPECIFIED.into(),
-            SocketAddr::V6(_) => Ipv6Addr::UNSPECIFIED.into(),
+            SocketAddr::V4(_) => local_ipv4.into(),
+            SocketAddr::V6(_) => local_ipv6.into(),
         };
         let local_addr = SocketAddr::new(local_ip, 0);
         if let Ok(client) = bind_and_connect_socket(&local_addr, &tracker_addr, interface)
@@ -352,8 +369,10 @@ async fn do_udp_announce(
     tracker_addr: &str,
     data: AnnounceRequest,
     interface: Option<&str>,
+    local_ipv4: Ipv4Addr,
+    local_ipv6: Ipv6Addr,
 ) -> io::Result<AnnounceResponse> {
-    let mut client = new_udp_client(tracker_addr, interface).await?;
+    let mut client = new_udp_client(tracker_addr, interface, local_ipv4, local_ipv6).await?;
 
     let request = udp::AnnounceRequest {
         info_hash: data.info_hash,
@@ -379,8 +398,10 @@ async fn do_udp_scrape(
     tracker_addr: &str,
     data: ScrapeRequest,
     interface: Option<&str>,
+    local_ipv4: Ipv4Addr,
+    local_ipv6: Ipv6Addr,
 ) -> io::Result<ScrapeResponse> {
-    let mut client = new_udp_client(tracker_addr, interface).await?;
+    let mut client = new_udp_client(tracker_addr, interface, local_ipv4, local_ipv6).await?;
 
     let request = udp::ScrapeRequest {
         info_hashes: data.info_hashes.clone(),

mtorrent-utils/Cargo.toml

@@ -27,6 +27,7 @@ socket2 = { workspace = true }
 
 [target.'cfg(not(windows))'.dependencies]
 libc = "0.2"
+sysinfo = "0.38"
 
 [target.'cfg(windows)'.dependencies]
 ipconfig = "0.3"

mtorrent-utils/src/ip.rs

@@ -1,7 +1,7 @@
 use bytes::Buf;
 use socket2::SockRef;
 use std::hash::{DefaultHasher, Hash, Hasher};
-use std::net::{Ipv4Addr, SocketAddrV4, SocketAddrV6};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
 use std::{io, ops};
 
 /// Get local (non-loopback) IPv4.
@@ -26,12 +26,82 @@ pub fn get_local_addr() -> io::Result<Ipv4Addr> {
         .filter(|adapter| matches!(adapter.oper_status(), ipconfig::OperStatus::IfOperStatusUp))
         .flat_map(ipconfig::Adapter::ip_addresses)
         .find_map(|addr| match addr {
-            std::net::IpAddr::V4(ipv4) => Some(*ipv4),
+            IpAddr::V4(ipv4) => Some(*ipv4),
             _ => None,
         })
         .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "IPv4 not found"))
 }
 
+#[cfg(windows)]
+fn get_adapter_addrs<'a>(
+    adapters: impl IntoIterator<Item = &'a ipconfig::Adapter>,
+    iface: &str,
+) -> impl Iterator<Item = &'a IpAddr> {
+    adapters
+        .into_iter()
+        .filter(move |adapter| {
+            matches!(adapter.oper_status(), ipconfig::OperStatus::IfOperStatusUp)
+                && (adapter.adapter_name() == iface || adapter.friendly_name() == iface)
+        })
+        .flat_map(ipconfig::Adapter::ip_addresses)
+}
+
+pub fn get_bind_addr_v4(interface: Option<&str>) -> Ipv4Addr {
+    let Some(iface) = interface else {
+        return Ipv4Addr::UNSPECIFIED;
+    };
+
+    #[cfg(windows)]
+    if let Ok(adapters) = ipconfig::get_adapters() {
+        let found = get_adapter_addrs(&adapters, iface).find_map(|addr| match addr {
+            IpAddr::V4(ipv4) => Some(*ipv4),
+            _ => None,
+        });
+        debug_assert!(found.is_some(), "failed to find network adapter");
+        return found.unwrap_or(Ipv4Addr::UNSPECIFIED);
+    }
+
+    #[cfg(not(windows))]
+    if let Some(network_data) = sysinfo::Networks::new_with_refreshed_list().get(iface) {
+        let found = network_data.ip_networks().iter().find_map(|network| match network.addr {
+            IpAddr::V4(ipv4) => Some(ipv4),
+            _ => None,
+        });
+        debug_assert!(found.is_some(), "failed to find network adapter");
+        return found.unwrap_or(Ipv4Addr::UNSPECIFIED);
+    }
+
+    Ipv4Addr::UNSPECIFIED
+}
+
+pub fn get_bind_addr_v6(interface: Option<&str>) -> Ipv6Addr {
+    let Some(iface) = interface else {
+        return Ipv6Addr::UNSPECIFIED;
+    };
+
+    #[cfg(windows)]
+    if let Ok(adapters) = ipconfig::get_adapters() {
+        let found = get_adapter_addrs(&adapters, iface).find_map(|addr| match addr {
+            IpAddr::V6(ipv6) => Some(*ipv6),
+            _ => None,
+        });
+        debug_assert!(found.is_some(), "failed to find network adapter");
+        return found.unwrap_or(Ipv6Addr::UNSPECIFIED);
+    }
+
+    #[cfg(not(windows))]
+    if let Some(network_data) = sysinfo::Networks::new_with_refreshed_list().get(iface) {
+        let found = network_data.ip_networks().iter().find_map(|network| match network.addr {
+            IpAddr::V6(ipv6) => Some(ipv6),
+            _ => None,
+        });
+        debug_assert!(found.is_some(), "failed to find network adapter");
+        return found.unwrap_or(Ipv6Addr::UNSPECIFIED);
+    }
+
+    Ipv6Addr::UNSPECIFIED
+}
+
 #[cfg(not(any(target_os = "linux", windows)))]
 pub fn get_local_addr() -> io::Result<Ipv4Addr> {
     Ok(Ipv4Addr::UNSPECIFIED)
@@ -242,4 +312,21 @@ mod tests {
             assert_eq!(idx, i);
         }
     }
+
+    #[test]
+    fn test_get_bind_addr() {
+        let iface = if cfg!(target_os = "windows") {
+            "Loopback Pseudo-Interface 1"
+        } else if cfg!(target_os = "macos") {
+            "lo0"
+        } else {
+            "lo"
+        };
+
+        let addr = get_bind_addr_v4(Some(iface));
+        assert_eq!(addr, Ipv4Addr::LOCALHOST);
+
+        let addr = get_bind_addr_v6(Some(iface));
+        assert_eq!(addr, Ipv6Addr::LOCALHOST);
+    }
 }

mtorrent/src/app/dht.rs

@@ -1,8 +1,7 @@
 use mtorrent_dht as dht;
-use mtorrent_utils::ip::bind_to_interface;
 use mtorrent_utils::{info_stopwatch, ip, upnp, worker};
 use std::io;
-use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+use std::net::{SocketAddr, SocketAddrV4};
 use std::path::PathBuf;
 use std::time::Duration;
 use tokio::net::UdpSocket;
@@ -92,13 +91,18 @@ async fn dht_main(
 ) {
     let _sw = info_stopwatch!("DHT");
 
-    let socket = match UdpSocket::bind(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port)).await {
+    let socket = match UdpSocket::bind(SocketAddrV4::new(
+        ip::get_bind_addr_v4(bind_interface.as_deref()),
+        local_port,
+    ))
+    .await
+    {
         Err(e) => return log::error!("Failed to create a UDP socket for DHT: {e}"),
         Ok(socket) => socket,
     };
 
     if let Some(interface) = bind_interface
-        && let Err(e) = bind_to_interface(&socket, &interface)
+        && let Err(e) = ip::bind_to_interface(&socket, &interface)
     {
         log::error!("Failed to bind DHT UDP socket to interface {interface}: {e}");
         return;