refactor target address

libs/hbb_common/src/config.rs

@@ -6,14 +6,13 @@ use sodiumoxide::crypto::sign;
 use std::{
     collections::HashMap,
     fs,
-    net::SocketAddr,
+    net::{IpAddr, Ipv4Addr, SocketAddr},
     path::{Path, PathBuf},
     sync::{Arc, Mutex, RwLock},
     time::SystemTime,
 };
 
 pub const APP_NAME: &str = "RustDesk";
-pub const BIND_INTERFACE: &str = "0.0.0.0";
 pub const RENDEZVOUS_TIMEOUT: u64 = 12_000;
 pub const CONNECT_TIMEOUT: u64 = 18_000;
 pub const COMPRESS_LEVEL: i32 = 3;
@@ -346,10 +345,10 @@ impl Config {
 
     #[inline]
     pub fn get_any_listen_addr() -> SocketAddr {
-        format!("{}:0", BIND_INTERFACE).parse().unwrap()
+        SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0)
     }
 
-    pub async fn get_rendezvous_server() -> SocketAddr {
+    pub fn get_rendezvous_server() -> String {
         let mut rendezvous_server = Self::get_option("custom-rendezvous-server");
         if rendezvous_server.is_empty() {
             rendezvous_server = CONFIG2.write().unwrap().rendezvous_server.clone();
@@ -363,11 +362,7 @@ impl Config {
         if !rendezvous_server.contains(":") {
             rendezvous_server = format!("{}:{}", rendezvous_server, RENDEZVOUS_PORT);
         }
-        if let Ok(addr) = crate::to_socket_addr(&rendezvous_server).await {
-            addr
-        } else {
-            Self::get_any_listen_addr()
-        }
+        rendezvous_server
     }
 
     pub fn get_rendezvous_servers() -> Vec<String> {

libs/hbb_common/src/lib.rs

@@ -27,9 +27,10 @@ pub use anyhow::{self, bail};
 pub use futures_util;
 pub mod config;
 pub mod fs;
-pub use socket_client::to_socket_addr;
 pub use sodiumoxide;
 pub use tokio_socks;
+pub use tokio_socks::IntoTargetAddr;
+pub use tokio_socks::TargetAddr;
 
 #[cfg(feature = "quic")]
 pub type Stream = quic::Connection;

libs/hbb_common/src/socket_client.rs

@@ -1,5 +1,5 @@
 use crate::{
-    config::{Config, NetworkType, RENDEZVOUS_TIMEOUT},
+    config::{Config, NetworkType},
     tcp::FramedStream,
     udp::FramedSocket,
     ResultType,
@@ -7,15 +7,43 @@ use crate::{
 use anyhow::{bail, Context};
 use std::net::SocketAddr;
 use tokio::net::ToSocketAddrs;
-use tokio_socks::IntoTargetAddr;
+use tokio_socks::{IntoTargetAddr, TargetAddr};
 
-// fn get_socks5_conf() -> Option<Socks5Server> {
-//     // Config::set_socks(Some(Socks5Server {
-//     //     proxy: "139.186.136.143:1080".to_owned(),
-//     //     ..Default::default()
-//     // }));
-//     Config::get_socks()
-// }
+fn to_socket_addr(host: &str) -> ResultType<SocketAddr> {
+    use std::net::ToSocketAddrs;
+    let addrs: Vec<SocketAddr> = host.to_socket_addrs()?.collect();
+    if addrs.is_empty() {
+        bail!("Failed to solve {}", host);
+    }
+    Ok(addrs[0])
+}
+
+pub fn get_target_addr(host: &str) -> ResultType<TargetAddr<'static>> {
+    let addr = match Config::get_network_type() {
+        NetworkType::Direct => to_socket_addr(&host)?.into_target_addr()?,
+        NetworkType::ProxySocks => host.into_target_addr()?,
+    }
+    .to_owned();
+    Ok(addr)
+}
+
+pub fn test_if_valid_server(host: &str) -> String {
+    let mut host = host.to_owned();
+    if !host.contains(":") {
+        host = format!("{}:{}", host, 0);
+    }
+
+    match Config::get_network_type() {
+        NetworkType::Direct => match to_socket_addr(&host) {
+            Err(err) => err.to_string(),
+            Ok(_) => "".to_owned(),
+        },
+        NetworkType::ProxySocks => match &host.into_target_addr() {
+            Err(err) => err.to_string(),
+            Ok(_) => "".to_owned(),
+        },
+    }
+}
 
 pub async fn connect_tcp<'t, T: IntoTargetAddr<'t>>(
     target: T,
@@ -47,49 +75,24 @@ pub async fn connect_tcp<'t, T: IntoTargetAddr<'t>>(
     }
 }
 
-fn native_to_socket_addr(host: &str) -> ResultType<SocketAddr> {
-    use std::net::ToSocketAddrs;
-    let addrs: Vec<SocketAddr> = host.to_socket_addrs()?.collect();
-    if addrs.is_empty() {
-        bail!("Failed to solve {}", host);
-    }
-    Ok(addrs[0])
-}
-
-pub async fn to_socket_addr(host: &str) -> ResultType<SocketAddr> {
-    Ok(
-        new_udp(host, Config::get_any_listen_addr(), RENDEZVOUS_TIMEOUT)
-            .await?
-            .1,
-    )
-}
-
-pub async fn new_udp<'t, T1: IntoTargetAddr<'t> + std::fmt::Display, T2: ToSocketAddrs>(
-    target: T1,
-    local: T2,
-    ms_timeout: u64,
-) -> ResultType<(FramedSocket, SocketAddr)> {
+pub async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<FramedSocket> {
     match Config::get_socks() {
-        None => Ok((
-            FramedSocket::new(local).await?,
-            native_to_socket_addr(&target.to_string())?,
-        )),
+        None => Ok(FramedSocket::new(local).await?),
         Some(conf) => {
-            let (socket, addr) = FramedSocket::new_proxy(
+            let socket = FramedSocket::new_proxy(
                 conf.proxy.as_str(),
-                target,
                 local,
                 conf.username.as_str(),
                 conf.password.as_str(),
                 ms_timeout,
             )
             .await?;
-            Ok((socket, addr))
+            Ok(socket)
         }
     }
 }
 
-pub async fn rebind<T: ToSocketAddrs>(local: T) -> ResultType<Option<FramedSocket>> {
+pub async fn rebind_udp<T: ToSocketAddrs>(local: T) -> ResultType<Option<FramedSocket>> {
     match Config::get_network_type() {
         NetworkType::Direct => Ok(Some(FramedSocket::new(local).await?)),
         _ => Ok(None),

libs/hbb_common/src/udp.rs

@@ -49,75 +49,79 @@ impl FramedSocket {
         bail!("could not resolve to any address");
     }
 
-    pub async fn new_proxy<'a, 't, P: ToProxyAddrs, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
+    pub async fn new_proxy<'a, 't, P: ToProxyAddrs, T: ToSocketAddrs>(
         proxy: P,
-        target: T1,
-        local: T2,
+        local: T,
         username: &'a str,
         password: &'a str,
         ms_timeout: u64,
-    ) -> ResultType<(Self, SocketAddr)> {
+    ) -> ResultType<Self> {
         let framed = if username.trim().is_empty() {
-            super::timeout(
-                ms_timeout,
-                Socks5UdpFramed::connect(proxy, target, Some(local)),
-            )
-            .await??
+            super::timeout(ms_timeout, Socks5UdpFramed::connect(proxy, Some(local))).await??
         } else {
             super::timeout(
                 ms_timeout,
-                Socks5UdpFramed::connect_with_password(
-                    proxy,
-                    target,
-                    Some(local),
-                    username,
-                    password,
-                ),
+                Socks5UdpFramed::connect_with_password(proxy, Some(local), username, password),
             )
             .await??
         };
-        let addr = if let TargetAddr::Ip(c) = framed.target_addr() {
-            c
-        } else {
-            unreachable!()
-        };
         log::trace!(
             "Socks5 udp connected, local addr: {}, target addr: {}",
             framed.local_addr().unwrap(),
-            &addr
+            framed.socks_addr()
         );
-        Ok((Self::ProxySocks(framed), addr))
+        Ok(Self::ProxySocks(framed))
     }
 
     #[inline]
-    pub async fn send(&mut self, msg: &impl Message, addr: SocketAddr) -> ResultType<()> {
-        let send_data = (Bytes::from(msg.write_to_bytes().unwrap()), addr);
+    pub async fn send(
+        &mut self,
+        msg: &impl Message,
+        addr: impl IntoTargetAddr<'_>,
+    ) -> ResultType<()> {
+        let addr = addr.into_target_addr()?.to_owned();
+        let send_data = Bytes::from(msg.write_to_bytes().unwrap());
         let _ = match self {
-            Self::Direct(f) => f.send(send_data).await?,
-            Self::ProxySocks(f) => f.send(send_data).await?,
+            Self::Direct(f) => match addr {
+                TargetAddr::Ip(addr) => f.send((send_data, addr)).await?,
+                _ => unreachable!(),
+            },
+            Self::ProxySocks(f) => f.send((send_data, addr)).await?,
         };
         Ok(())
     }
 
+    // https://stackoverflow.com/a/68733302/1926020
     #[inline]
-    pub async fn send_raw(&mut self, msg: &'static [u8], addr: SocketAddr) -> ResultType<()> {
+    pub async fn send_raw(
+        &mut self,
+        msg: &'static [u8],
+        addr: impl IntoTargetAddr<'static>,
+    ) -> ResultType<()> {
+        let addr = addr.into_target_addr()?.to_owned();
+
         let _ = match self {
-            Self::Direct(f) => f.send((Bytes::from(msg), addr)).await?,
+            Self::Direct(f) => match addr {
+                TargetAddr::Ip(addr) => f.send((Bytes::from(msg), addr)).await?,
+                _ => unreachable!(),
+            },
             Self::ProxySocks(f) => f.send((Bytes::from(msg), addr)).await?,
         };
         Ok(())
     }
 
     #[inline]
-    pub async fn next(&mut self) -> Option<ResultType<(BytesMut, SocketAddr)>> {
+    pub async fn next(&mut self) -> Option<ResultType<(BytesMut, TargetAddr<'static>)>> {
         match self {
             Self::Direct(f) => match f.next().await {
-                Some(Ok((data, addr))) => Some(Ok((data, addr))),
+                Some(Ok((data, addr))) => {
+                    Some(Ok((data, addr.into_target_addr().unwrap().to_owned())))
+                }
                 Some(Err(e)) => Some(Err(anyhow!(e))),
                 None => None,
             },
             Self::ProxySocks(f) => match f.next().await {
-                Some(Ok((data, addr))) => Some(Ok((data.data, addr))),
+                Some(Ok((data, _))) => Some(Ok((data.data, data.dst_addr))),
                 Some(Err(e)) => Some(Err(anyhow!(e))),
                 None => None,
             },
@@ -125,7 +129,10 @@ impl FramedSocket {
     }
 
     #[inline]
-    pub async fn next_timeout(&mut self, ms: u64) -> Option<ResultType<(BytesMut, SocketAddr)>> {
+    pub async fn next_timeout(
+        &mut self,
+        ms: u64,
+    ) -> Option<ResultType<(BytesMut, TargetAddr<'static>)>> {
         if let Ok(res) =
             tokio::time::timeout(std::time::Duration::from_millis(ms), self.next()).await
         {