fix(tuic): not connecting on windows

clash_lib/src/proxy/tuic/mod.rs

@@ -54,9 +54,8 @@ use rustls::client::ClientConfig as TlsConfig;
 use self::types::{CongestionControl, TuicConnection, UdpRelayMode, UdpSession};
 
 use super::{
-    datagram::UdpPacket,
-    utils::{get_outbound_interface, Interface},
-    ConnectorType, HandlerCommonOptions, OutboundHandler, OutboundType,
+    datagram::UdpPacket, ConnectorType, HandlerCommonOptions, OutboundHandler,
+    OutboundType,
 };
 
 #[derive(Debug, Clone)]
@@ -165,7 +164,7 @@ impl Handler {
     async fn init_endpoint(
         opts: HandlerOptions,
         resolver: ThreadSafeDNSResolver,
-        #[cfg(any(target_os = "linux", target_os = "android"))] so_mark: Option<u32>,
+        sess: &Session,
     ) -> Result<TuicEndpoint> {
         let mut crypto =
             TlsConfig::builder_with_protocol_versions(&[&rustls::version::TLS13])
@@ -199,22 +198,20 @@ impl Handler {
         quinn_config.transport_config(Arc::new(transport_config));
 
         let socket = {
-            let iface = get_outbound_interface();
-
             if resolver.ipv6() {
                 new_udp_socket(
                     Some((Ipv6Addr::UNSPECIFIED, 0).into()),
-                    iface.map(|x| Interface::Name(x.name.clone())),
+                    sess.iface.clone(),
                     #[cfg(any(target_os = "linux", target_os = "android"))]
-                    so_mark,
+                    sess.so_mark,
                 )
                 .await?
             } else {
                 new_udp_socket(
                     Some((Ipv4Addr::UNSPECIFIED, 0).into()),
-                    iface.map(|x| Interface::Name(x.name.clone())),
+                    sess.iface.clone(),
                     #[cfg(any(target_os = "linux", target_os = "android"))]
-                    so_mark,
+                    sess.so_mark,
                 )
                 .await?
             }
@@ -250,17 +247,12 @@ impl Handler {
     async fn get_conn(
         &self,
         resolver: &ThreadSafeDNSResolver,
-        #[allow(unused)] sess: &Session, // linux only
+        sess: &Session,
     ) -> Result<Arc<TuicConnection>> {
         let endpoint = self
             .ep
             .get_or_try_init(|| {
-                Self::init_endpoint(
-                    self.opts.clone(),
-                    resolver.clone(),
-                    #[cfg(any(target_os = "linux", target_os = "android"))]
-                    sess.so_mark,
-                )
+                Self::init_endpoint(self.opts.clone(), resolver.clone(), sess)
             })
             .await?;
 

clash_lib/src/proxy/utils/platform/win.rs

@@ -1,6 +1,6 @@
 use network_interface::NetworkInterfaceConfig;
 use std::{io, net::SocketAddr, os::windows::io::AsRawSocket};
-use tracing::{error, trace, warn};
+use tracing::{debug, error, warn};
 use windows::Win32::{
     Foundation::GetLastError,
     Networking::WinSock::{
@@ -19,17 +19,18 @@
         Interface::IpAddr(ip) => socket.bind(&SocketAddr::new(*ip, 0).into()),
         Interface::Name(name) => {
             // TODO: we should avoid calling `show` multiple times
-            let idx = network_interface::NetworkInterface::show()
+            let iface = network_interface::NetworkInterface::show()
                 .map_err(|x| new_io_error(x.to_string().as_str()))?
                 .into_iter()
                 .find_map(|iface| {
                     if &iface.name == name {
-                        Some(iface.index)
+                        Some(iface)
                     } else {
                         None
                     }
-                })
-                .unwrap_or_default();
+                });
+
+            let idx = iface.as_ref().map(|iface| iface.index).unwrap_or_default();
             if idx == 0 {
                 warn!("failed to get interface index for {}", name);
                 return Err(io::Error::new(
@@ -38,7 +39,39 @@
                 ));
             }
 
-            trace!("interface {} index is {}", name, idx);
+            let ip = match iface {
+                Some(iface) => iface.addr.iter().find_map(|addr| {
+                    if family == socket2::Domain::IPV4 {
+                        if addr.ip().is_ipv4() {
+                            Some(addr.ip())
+                        } else {
+                            None
+                        }
+                    } else {
+                        if addr.ip().is_ipv6() {
+                            Some(addr.ip())
+                        } else {
+                            None
+                        }
+                    }
+                }),
+                None => None,
+            };
+
+            debug!(
+                "binding socket to interface: {}, index {}, ip {:?}",
+                name, idx, ip
+            );
+
+            if let Some(ip) = ip {
+                socket.bind(&SocketAddr::new(ip, 0).into())?;
+            } else {
+                warn!("failed to get address for interface {}", name);
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    format!("failed to get address for interface {}", name),
+                ));
+            }
 
             let handle = SOCKET(socket.as_raw_socket().try_into().unwrap());