refactor to_socket_addr and dns_check

libs/hbb_common/src/config.rs

@@ -349,7 +349,7 @@ impl Config {
         format!("{}:0", BIND_INTERFACE).parse().unwrap()
     }
 
-    pub fn get_rendezvous_server() -> SocketAddr {
+    pub async fn get_rendezvous_server() -> SocketAddr {
         let mut rendezvous_server = Self::get_option("custom-rendezvous-server");
         if rendezvous_server.is_empty() {
             rendezvous_server = CONFIG2.write().unwrap().rendezvous_server.clone();
@@ -363,7 +363,7 @@ impl Config {
         if !rendezvous_server.contains(":") {
             rendezvous_server = format!("{}:{}", rendezvous_server, RENDEZVOUS_PORT);
         }
-        if let Ok(addr) = crate::to_socket_addr(&rendezvous_server) {
+        if let Ok(addr) = crate::to_socket_addr(&rendezvous_server).await {
             addr
         } else {
             Self::get_any_listen_addr()

libs/hbb_common/src/lib.rs

@@ -9,15 +9,15 @@ pub use protobuf;
 use std::{
     fs::File,
     io::{self, BufRead},
-    net::{Ipv4Addr, SocketAddr, SocketAddrV4, ToSocketAddrs},
+    net::{Ipv4Addr, SocketAddr, SocketAddrV4},
     path::Path,
     time::{self, SystemTime, UNIX_EPOCH},
 };
 pub use tokio;
 pub use tokio_util;
+pub mod socket_client;
 pub mod tcp;
 pub mod udp;
-pub mod socket_client;
 pub use env_logger;
 pub use log;
 pub mod bytes_codec;
@@ -27,6 +27,7 @@ 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;
 
@@ -149,14 +150,6 @@ pub fn get_version_from_url(url: &str) -> String {
     "".to_owned()
 }
 
-pub fn to_socket_addr(host: &str) -> ResultType<SocketAddr> {
-    let addrs: Vec<SocketAddr> = host.to_socket_addrs()?.collect();
-    if addrs.is_empty() {
-        bail!("Failed to solve {}", host);
-    }
-    Ok(addrs[0])
-}
-
 pub fn gen_version() {
     let mut file = File::create("./src/version.rs").unwrap();
     for line in read_lines("Cargo.toml").unwrap() {

libs/hbb_common/src/socket_client.rs

@@ -1,5 +1,5 @@
 use crate::{
-    config::{Config, NetworkType},
+    config::{Config, NetworkType, RENDEZVOUS_TIMEOUT},
     tcp::FramedStream,
     udp::FramedSocket,
     ResultType,
@@ -47,15 +47,35 @@ pub async fn connect_tcp<'t, T: IntoTargetAddr<'t>>(
     }
 }
 
-pub async fn connect_udp<'t, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
+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, Option<SocketAddr>)> {
+) -> ResultType<(FramedSocket, SocketAddr)> {
     match Config::get_socks() {
-        None => Ok((FramedSocket::new(local).await?, None)),
+        None => Ok((
+            FramedSocket::new(local).await?,
+            native_to_socket_addr(&target.to_string())?,
+        )),
         Some(conf) => {
-            let (socket, addr) = FramedSocket::connect(
+            let (socket, addr) = FramedSocket::new_proxy(
                 conf.proxy.as_str(),
                 target,
                 local,
@@ -64,12 +84,12 @@ pub async fn connect_udp<'t, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
                 ms_timeout,
             )
             .await?;
-            Ok((socket, Some(addr)))
+            Ok((socket, addr))
         }
     }
 }
 
-pub async fn reconnect_udp<T: ToSocketAddrs>(local: T) -> ResultType<Option<FramedSocket>> {
+pub async fn rebind<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,7 +49,7 @@ impl FramedSocket {
         bail!("could not resolve to any address");
     }
 
-    pub async fn connect<'a, 't, P: ToProxyAddrs, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
+    pub async fn new_proxy<'a, 't, P: ToProxyAddrs, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
         proxy: P,
         target: T1,
         local: T2,