nat64

libs/hbb_common/src/config.rs

@@ -511,13 +511,12 @@ impl Config {
     }
 
     #[inline]
-    pub fn get_any_listen_addr() -> SocketAddr {
-        SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0)
-    }
-
-    #[inline]
-    pub fn get_any_listen_addr_v6() -> SocketAddr {
-        SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0)
+    pub fn get_any_listen_addr(is_ipv4: bool) -> SocketAddr {
+        if is_ipv4 {
+            SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0)
+        } else {
+            SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), 0)
+        }
     }
 
     pub fn get_rendezvous_server() -> String {

libs/hbb_common/src/lib.rs

@@ -130,7 +130,7 @@ impl AddrMangle {
     pub fn decode(bytes: &[u8]) -> SocketAddr {
         if bytes.len() > 16 {
             if bytes.len() != 18 {
-                return Config::get_any_listen_addr_v6();
+                return Config::get_any_listen_addr(false);
             }
             #[allow(invalid_value)]
             let mut tmp: [u8; 2] = unsafe { std::mem::MaybeUninit::uninit().assume_init() };
@@ -300,3 +300,10 @@ mod tests {
         );
     }
 }
+
+#[inline]
+pub fn is_ipv4_str(id: &str) -> bool {
+    regex::Regex::new(r"^\d+\.\d+\.\d+\.\d+(:\d+)?$")
+        .unwrap()
+        .is_match(id)
+}

libs/hbb_common/src/socket_client.rs

@@ -85,10 +85,21 @@ impl<'a> IntoTargetAddr2<'a> for &str {
 
 pub async fn connect_tcp<'t, T: IntoTargetAddr2<'t> + std::fmt::Debug>(
     target: T,
-    local: SocketAddr,
     ms_timeout: u64,
 ) -> ResultType<FramedStream> {
     let target_addr = target.into_target_addr2()?;
+    let local = Config::get_any_listen_addr(is_ipv4(&target_addr));
+    connect_tcp_local(target_addr, local, ms_timeout)
+        .await
+        .context(format!("Invalid target addr: {:?}", target))
+}
+
+pub async fn connect_tcp_local<'t, T: IntoTargetAddr<'t> + std::fmt::Debug>(
+    target: T,
+    local: SocketAddr,
+    ms_timeout: u64,
+) -> ResultType<FramedStream> {
+    let target_addr = target.into_target_addr()?;
     if let Some(conf) = Config::get_socks() {
         return FramedStream::connect(
             conf.proxy.as_str(),
@@ -100,13 +111,43 @@ pub async fn connect_tcp<'t, T: IntoTargetAddr2<'t> + std::fmt::Debug>(
         )
         .await;
     }
-    let addr = ToSocketAddrs::to_socket_addrs(&target_addr)?
+    let mut addr = ToSocketAddrs::to_socket_addrs(&target_addr)?
         .next()
-        .context(format!("Invalid target addr: {:?}", target))?;
+        .context(format!("Invalid target addr: {:?}", target_addr))?;
+    if local.is_ipv6() && addr.is_ipv4() {
+        addr = query_nip_io(&addr)?;
+    }
     Ok(FramedStream::new(addr, local, ms_timeout).await?)
 }
 
-pub async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<FramedSocket> {
+#[inline]
+pub fn is_ipv4(target: &TargetAddr<'_>) -> bool {
+    match target {
+        TargetAddr::Ip(addr) => addr.is_ipv4(),
+        _ => true,
+    }
+}
+
+#[inline]
+pub fn query_nip_io(addr: &SocketAddr) -> ResultType<SocketAddr> {
+    to_socket_addr(format!("{}.nip.io:{}", addr.ip(), addr.port()))
+}
+
+#[inline]
+pub fn ipv4_to_ipv6(addr: String, ipv4: bool) -> String {
+    if !ipv4 && crate::is_ipv4_str(&addr) {
+        if let Some(ip) = addr.split(":").next() {
+            return addr.replace(ip, &format!("{}.nip.io", ip));
+        }
+    }
+    addr
+}
+
+pub async fn new_udp_for(target: &TargetAddr<'_>, ms_timeout: u64) -> ResultType<FramedSocket> {
+    new_udp(Config::get_any_listen_addr(is_ipv4(target)), ms_timeout).await
+}
+
+async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<FramedSocket> {
     match Config::get_socks() {
         None => Ok(FramedSocket::new(to_socket_addr(&local)?).await?),
         Some(conf) => {
@@ -123,19 +164,49 @@ pub async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<
     }
 }
 
-pub async fn rebind_udp<T: ToSocketAddrs>(local: T) -> ResultType<Option<FramedSocket>> {
+pub async fn rebind_udp_for(target: &TargetAddr<'_>) -> ResultType<Option<FramedSocket>> {
     match Config::get_network_type() {
-        NetworkType::Direct => Ok(Some(FramedSocket::new(to_socket_addr(local)?).await?)),
+        NetworkType::Direct => Ok(Some(
+            FramedSocket::new(Config::get_any_listen_addr(is_ipv4(target))).await?,
+        )),
         _ => Ok(None),
     }
 }
+
 #[cfg(test)]
 mod tests {
     use super::*;
     #[test]
     fn test_to_socket_addr() {
-        assert_eq!(to_socket_addr("127.0.0.1:8080").unwrap(), "127.0.0.1:8080".parse().unwrap());
+        assert_eq!(
+            to_socket_addr("127.0.0.1:8080").unwrap(),
+            "127.0.0.1:8080".parse().unwrap()
+        );
         assert!(to_socket_addr("[ff::]:0").unwrap().is_ipv6());
         assert!(to_socket_addr("xx").is_err());
     }
-}
+
+    #[test]
+    fn test_nat64() {
+        assert_eq!(ipv4_to_ipv6("1.1.1.1".to_owned(), true), "1.1.1.1");
+        assert_eq!(ipv4_to_ipv6("1.1.1.1".to_owned(), false), "1.1.1.1.nip.io");
+        assert_eq!(
+            ipv4_to_ipv6("1.1.1.1:8080".to_owned(), false),
+            "1.1.1.1.nip.io:8080"
+        );
+        assert_eq!(
+            ipv4_to_ipv6("rustdesk.com".to_owned(), false),
+            "rustdesk.com"
+        );
+        if to_socket_addr("rustdesk.com:80").unwrap().is_ipv6() {
+            assert!(query_nip_io(&"1.1.1.1:80".parse().unwrap())
+                .unwrap()
+                .is_ipv6());
+            return;
+        }
+        assert_eq!(
+            query_nip_io(&"1.1.1.1:80".parse().unwrap()).unwrap(),
+            "1.1.1.1:80".parse().unwrap()
+        );
+    }
+}