refactor udp framed

Signed-off-by: fufesou <shuanglongchen@yeah.net>

Cargo.lock

@@ -1553,7 +1553,6 @@ name = "hbb_common"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "async-trait",
  "bytes",
  "confy",
  "directories-next",
@@ -1561,13 +1560,10 @@ dependencies = [
  "env_logger 0.9.0",
  "filetime",
  "futures",
- "futures-core",
- "futures-sink",
  "futures-util",
  "lazy_static",
  "log",
  "mac_address",
- "pin-project",
  "protobuf",
  "protobuf-codegen-pure",
  "quinn",

libs/hbb_common/Cargo.toml

@@ -29,10 +29,6 @@ dirs-next = "2.0"
 filetime = "0.2"
 sodiumoxide = "0.2"
 tokio-socks = { git = "https://github.com/fufesou/tokio-socks" }
-futures-core = "0.3"
-futures-sink = "0.3"
-async-trait = "0.1"
-pin-project = "1"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 mac_address = "1.1"

libs/hbb_common/src/config.rs

@@ -55,6 +55,12 @@ pub const RENDEZVOUS_SERVERS: &'static [&'static str] = &[
 pub const RENDEZVOUS_PORT: i32 = 21116;
 pub const RELAY_PORT: i32 = 21117;
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum NetworkType {
+    Direct,
+    ProxySocks,
+}
+
 #[derive(Debug, Default, Serialize, Deserialize, Clone)]
 pub struct Config {
     #[serde(default)]
@@ -642,6 +648,13 @@ impl Config {
     pub fn get_socks() -> Option<Socks5Server> {
         CONFIG2.read().unwrap().socks.clone()
     }
+
+    pub fn get_network_type() -> NetworkType {
+        match &CONFIG2.read().unwrap().socks {
+            None => NetworkType::Direct,
+            Some(_) => NetworkType::ProxySocks,
+        }
+    }
 }
 
 const PEERS: &str = "peers";

libs/hbb_common/src/lib.rs

@@ -24,8 +24,6 @@ pub mod bytes_codec;
 #[cfg(feature = "quic")]
 pub mod quic;
 pub use anyhow::{self, bail};
-pub use futures_core;
-pub use futures_sink;
 pub use futures_util;
 pub mod config;
 pub mod fs;

libs/hbb_common/src/socket_client.rs

@@ -1,22 +1,21 @@
 use crate::{
-    config::{Config, Socks5Server},
+    config::{Config, NetworkType},
     tcp::FramedStream,
-    udp::{FramedSocket, UdpFramedWrapper},
+    udp::FramedSocket,
     ResultType,
 };
 use anyhow::{bail, Context};
 use std::net::SocketAddr;
 use tokio::net::ToSocketAddrs;
-use tokio_socks::{udp::Socks5UdpFramed, IntoTargetAddr};
+use tokio_socks::IntoTargetAddr;
-use tokio_util::{codec::BytesCodec, udp::UdpFramed};
 
-pub fn get_socks5_conf() -> Option<Socks5Server> {
+// fn get_socks5_conf() -> Option<Socks5Server> {
-    // Config::set_socks(Some(Socks5Server {
+//     // Config::set_socks(Some(Socks5Server {
-    //     proxy: "139.186.136.143:1080".to_owned(),
+//     //     proxy: "139.186.136.143:1080".to_owned(),
-    //     ..Default::default()
+//     //     ..Default::default()
-    // }));
+//     // }));
-    Config::get_socks()
+//     Config::get_socks()
-}
+// }
 
 pub async fn connect_tcp<'t, T: IntoTargetAddr<'t>>(
     target: T,
@@ -25,7 +24,7 @@ pub async fn connect_tcp<'t, T: IntoTargetAddr<'t>>(
 ) -> ResultType<FramedStream> {
     let target_addr = target.into_target_addr()?;
 
-    if let Some(conf) = get_socks5_conf() {
+    if let Some(conf) = Config::get_socks() {
         FramedStream::connect(
             conf.proxy.as_str(),
             target_addr,
@@ -48,26 +47,13 @@ pub async fn connect_tcp<'t, T: IntoTargetAddr<'t>>(
     }
 }
 
-// TODO: merge connect_udp and connect_udp_socks5
+pub async fn connect_udp<'t, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
-pub async fn connect_udp_socket<T1: ToSocketAddrs>(
-    local: T1,
-) -> ResultType<(
-    FramedSocket<UdpFramedWrapper<UdpFramed<BytesCodec>>>,
-    Option<SocketAddr>,
-)> {
-    Ok((FramedSocket::new(local).await?, None))
-}
-
-pub async fn connect_udp_socks5<'t, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
     target: T1,
     local: T2,
-    socks5: &Option<Socks5Server>,
     ms_timeout: u64,
-) -> ResultType<(
+) -> ResultType<(FramedSocket, Option<SocketAddr>)> {
-    FramedSocket<UdpFramedWrapper<Socks5UdpFramed>>,
+    match Config::get_socks() {
-    Option<SocketAddr>,
+        None => Ok((FramedSocket::new(local).await?, None)),
-)> {
-    match socks5 {
         Some(conf) => {
             let (socket, addr) = FramedSocket::connect(
                 conf.proxy.as_str(),
@@ -80,8 +66,12 @@ pub async fn connect_udp_socks5<'t, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
             .await?;
             Ok((socket, Some(addr)))
         }
-        None => {
+    }
-            bail!("Nil socks5 server config")
+}
-        }
+
+pub async fn reconnect_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

@@ -2,59 +2,16 @@ use crate::{bail, ResultType};
 use anyhow::anyhow;
 use bytes::{Bytes, BytesMut};
 use futures::{SinkExt, StreamExt};
-use futures_core::Stream;
-use futures_sink::Sink;
-use pin_project::pin_project;
 use protobuf::Message;
 use socket2::{Domain, Socket, Type};
-use std::{
+use std::net::SocketAddr;
-    net::SocketAddr,
-    ops::{Deref, DerefMut},
-    pin::Pin,
-    task::{Context, Poll},
-};
 use tokio::net::{ToSocketAddrs, UdpSocket};
-use tokio_socks::{
+use tokio_socks::{udp::Socks5UdpFramed, IntoTargetAddr, TargetAddr, ToProxyAddrs};
-    udp::{Socks5UdpFramed, Socks5UdpMessage},
-    IntoTargetAddr, TargetAddr, ToProxyAddrs,
-};
 use tokio_util::{codec::BytesCodec, udp::UdpFramed};
 
-pub struct FramedSocket<F>(F);
+pub enum FramedSocket {
-
+    Direct(UdpFramed<BytesCodec>),
-#[pin_project]
+    ProxySocks(Socks5UdpFramed),
-pub struct UdpFramedWrapper<F>(#[pin] F);
-
-pub trait BytesMutGetter<'a> {
-    fn get_bytes_mut(&'a self) -> &'a BytesMut;
-}
-
-impl<F> Deref for FramedSocket<F> {
-    type Target = F;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<F> DerefMut for FramedSocket<F> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl<F> Deref for UdpFramedWrapper<F> {
-    type Target = F;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<F> DerefMut for UdpFramedWrapper<F> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
 }
 
 fn new_socket(addr: SocketAddr, reuse: bool) -> Result<Socket, std::io::Error> {
@@ -74,29 +31,24 @@ fn new_socket(addr: SocketAddr, reuse: bool) -> Result<Socket, std::io::Error> {
     Ok(socket)
 }
 
-impl FramedSocket<UdpFramedWrapper<UdpFramed<BytesCodec>>> {
+impl FramedSocket {
     pub async fn new<T: ToSocketAddrs>(addr: T) -> ResultType<Self> {
         let socket = UdpSocket::bind(addr).await?;
-        Ok(Self(UdpFramedWrapper(UdpFramed::new(
+        Ok(Self::Direct(UdpFramed::new(socket, BytesCodec::new())))
-            socket,
-            BytesCodec::new(),
-        ))))
     }
 
     #[allow(clippy::never_loop)]
     pub async fn new_reuse<T: std::net::ToSocketAddrs>(addr: T) -> ResultType<Self> {
         for addr in addr.to_socket_addrs()? {
             let socket = new_socket(addr, true)?.into_udp_socket();
-            return Ok(Self(UdpFramedWrapper(UdpFramed::new(
+            return Ok(Self::Direct(UdpFramed::new(
                 UdpSocket::from_std(socket)?,
                 BytesCodec::new(),
-            ))));
+            )));
         }
         bail!("could not resolve to any address");
     }
-}
 
-impl FramedSocket<UdpFramedWrapper<Socks5UdpFramed>> {
     pub async fn connect<'a, 't, P: ToProxyAddrs, T1: IntoTargetAddr<'t>, T2: ToSocketAddrs>(
         proxy: P,
         target: T1,
@@ -134,43 +86,48 @@ impl FramedSocket<UdpFramedWrapper<Socks5UdpFramed>> {
             framed.local_addr().unwrap(),
             &addr
         );
-        Ok((Self(UdpFramedWrapper(framed)), addr))
+        Ok((Self::ProxySocks(framed), addr))
-    }
-}
-
-// TODO: simplify this constraint
-impl<F> FramedSocket<F>
-where
-    F: Unpin + Stream + Sink<(Bytes, SocketAddr)>,
-    <F as Sink<(Bytes, SocketAddr)>>::Error: Sync + Send + std::error::Error + 'static,
-{
-    pub async fn new_with(self) -> ResultType<Self> {
-        Ok(self)
     }
 
     #[inline]
     pub async fn send(&mut self, msg: &impl Message, addr: SocketAddr) -> ResultType<()> {
-        self.0
+        let send_data = (Bytes::from(msg.write_to_bytes().unwrap()), addr);
-            .send((Bytes::from(msg.write_to_bytes().unwrap()), addr))
+        let _ = match self {
-            .await?;
+            Self::Direct(f) => f.send(send_data).await?,
+            Self::ProxySocks(f) => f.send(send_data).await?,
+        };
         Ok(())
     }
 
     #[inline]
     pub async fn send_raw(&mut self, msg: &'static [u8], addr: SocketAddr) -> ResultType<()> {
-        self.0.send((Bytes::from(msg), addr)).await?;
+        let _ = match self {
+            Self::Direct(f) => f.send((Bytes::from(msg), addr)).await?,
+            Self::ProxySocks(f) => f.send((Bytes::from(msg), addr)).await?,
+        };
         Ok(())
     }
 
     #[inline]
-    pub async fn next(&mut self) -> Option<<F as Stream>::Item> {
+    pub async fn next(&mut self) -> Option<ResultType<(BytesMut, SocketAddr)>> {
-        self.0.next().await
+        match self {
+            Self::Direct(f) => match f.next().await {
+                Some(Ok((data, addr))) => Some(Ok((data, addr))),
+                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(Err(e)) => Some(Err(anyhow!(e))),
+                None => None,
+            },
+        }
     }
 
     #[inline]
-    pub async fn next_timeout(&mut self, ms: u64) -> Option<<F as Stream>::Item> {
+    pub async fn next_timeout(&mut self, ms: u64) -> Option<ResultType<(BytesMut, SocketAddr)>> {
         if let Ok(res) =
-            tokio::time::timeout(std::time::Duration::from_millis(ms), self.0.next()).await
+            tokio::time::timeout(std::time::Duration::from_millis(ms), self.next()).await
         {
             res
         } else {
@@ -178,59 +135,3 @@ where
         }
     }
 }
-
-impl<'a> BytesMutGetter<'a> for BytesMut {
-    fn get_bytes_mut(&'a self) -> &'a BytesMut {
-        self
-    }
-}
-
-impl<'a> BytesMutGetter<'a> for Socks5UdpMessage {
-    fn get_bytes_mut(&'a self) -> &'a BytesMut {
-        &self.data
-    }
-}
-
-impl<F, M, E> Stream for UdpFramedWrapper<F>
-where
-    F: Stream<Item = std::result::Result<(M, SocketAddr), E>>,
-    for<'b> M: BytesMutGetter<'b> + std::fmt::Debug,
-    E: std::error::Error + Into<anyhow::Error>,
-{
-    type Item = ResultType<(BytesMut, SocketAddr)>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match self.project().0.poll_next(cx) {
-            Poll::Ready(Some(Ok((msg, addr)))) => {
-                Poll::Ready(Some(Ok((msg.get_bytes_mut().clone(), addr))))
-            }
-            Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(anyhow!(e)))),
-            Poll::Ready(None) => Poll::Ready(None),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
-impl<F> Sink<(Bytes, SocketAddr)> for UdpFramedWrapper<F>
-where
-    F: Sink<(Bytes, SocketAddr)>,
-{
-    type Error = <F as Sink<(Bytes, SocketAddr)>>::Error;
-
-    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().0.poll_ready(cx)
-    }
-
-    fn start_send(self: Pin<&mut Self>, item: (Bytes, SocketAddr)) -> Result<(), Self::Error> {
-        self.project().0.start_send(item)
-    }
-
-    #[allow(unused_mut)]
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().0.poll_flush(cx)
-    }
-
-    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.project().0.poll_close(cx)
-    }
-}

src/common.rs

@@ -1,27 +1,20 @@
-use std::net::SocketAddr;
-
 pub use arboard::Clipboard as ClipboardContext;
 use hbb_common::{
     allow_err,
     anyhow::bail,
-    bytes::{Bytes, BytesMut},
     compress::{compress as compress_func, decompress},
-    config::{Config, COMPRESS_LEVEL, RENDEZVOUS_TIMEOUT},
+    config::{Config, NetworkType, COMPRESS_LEVEL, RENDEZVOUS_TIMEOUT},
-    futures_core::Stream,
-    futures_sink::Sink,
     log,
     message_proto::*,
     protobuf::Message as _,
     protobuf::ProtobufEnum,
     rendezvous_proto::*,
-    sleep, socket_client, tokio,
+    sleep, socket_client, tokio, ResultType,
-    udp::FramedSocket,
-    ResultType,
 };
 #[cfg(any(target_os = "android", target_os = "ios", feature = "cli"))]
 use hbb_common::{config::RENDEZVOUS_PORT, futures::future::join_all};
 use std::{
-    future::Future,
+    net::SocketAddr,
     sync::{Arc, Mutex},
 };
 
@@ -274,7 +267,9 @@ async fn test_nat_type_() -> ResultType<bool> {
             RENDEZVOUS_TIMEOUT,
         )
         .await?;
-        addr = socket.local_addr();
+        if Config::get_network_type() == NetworkType::Direct {
+            addr = socket.local_addr();
+        }
         socket.send(&msg_out).await?;
         if let Some(Ok(bytes)) = socket.next_timeout(3000).await {
             if let Ok(msg_in) = RendezvousMessage::parse_from_bytes(&bytes) {
@@ -448,35 +443,12 @@ async fn _check_software_update() -> hbb_common::ResultType<()> {
     sleep(3.).await;
 
     let rendezvous_server = get_rendezvous_server(1_000).await;
-    let socks5_conf = socket_client::get_socks5_conf();
+    let (mut socket, _) = socket_client::connect_udp(
-    if socks5_conf.is_some() {
+        rendezvous_server,
-        let conn_fn = |bind_addr: SocketAddr| async move {
+        Config::get_any_listen_addr(),
-            socket_client::connect_udp_socks5(
+        RENDEZVOUS_TIMEOUT,
-                rendezvous_server,
+    )
-                bind_addr,
+    .await?;
-                &socks5_conf,
-                RENDEZVOUS_TIMEOUT,
-            )
-            .await
-        };
-        _inner_check_software_update(conn_fn, rendezvous_server).await
-    } else {
-        _inner_check_software_update(socket_client::connect_udp_socket, rendezvous_server).await
-    }
-}
-
-pub async fn _inner_check_software_update<'a, F, Fut, Frm>(
-    conn_fn: F,
-    rendezvous_server: SocketAddr,
-) -> ResultType<()>
-where
-    F: FnOnce(SocketAddr) -> Fut,
-    Fut: Future<Output = ResultType<(FramedSocket<Frm>, Option<SocketAddr>)>>,
-    Frm: Unpin + Stream<Item = ResultType<(BytesMut, SocketAddr)>> + Sink<(Bytes, SocketAddr)>,
-    <Frm as Sink<(Bytes, SocketAddr)>>::Error: Sync + Send + std::error::Error + 'static,
-{
-    sleep(3.).await;
-    let (mut socket, _) = conn_fn(Config::get_any_listen_addr()).await?;
     let mut msg_out = RendezvousMessage::new();
     msg_out.set_software_update(SoftwareUpdate {
         url: crate::VERSION.to_owned(),

src/rendezvous_mediator.rs

@@ -2,11 +2,8 @@ use crate::server::{check_zombie, new as new_server, ServerPtr};
 use hbb_common::{
     allow_err,
     anyhow::bail,
-    bytes::{Bytes, BytesMut},
     config::{Config, RENDEZVOUS_PORT, RENDEZVOUS_TIMEOUT},
     futures::future::join_all,
-    futures_core::Stream,
-    futures_sink::Sink,
     log,
     protobuf::Message as _,
     rendezvous_proto::*,
@@ -19,7 +16,6 @@ use hbb_common::{
     AddrMangle, ResultType,
 };
 use std::{
-    future::Future,
     net::SocketAddr,
     sync::{Arc, Mutex},
     time::SystemTime,
@@ -63,35 +59,36 @@ impl RendezvousMediator {
                     let server = server.clone();
                     let servers = servers.clone();
                     futs.push(tokio::spawn(async move {
-                        let socks5_conf = socket_client::get_socks5_conf();
+                        allow_err!(Self::start(server, host, servers).await);
-                        if socks5_conf.is_some() {
+                        // let socks5_conf = socket_client::get_socks5_conf();
-                            let target = format!("{}:{}", host, RENDEZVOUS_PORT);
+                        // if socks5_conf.is_some() {
-                            let conn_fn = |bind_addr: SocketAddr| {
+                        //     let target = format!("{}:{}", host, RENDEZVOUS_PORT);
-                                let target = target.clone();
+                        //     let conn_fn = |bind_addr: SocketAddr| {
-                                let conf_ref = &socks5_conf;
+                        //         let target = target.clone();
-                                async move {
+                        //         let conf_ref = &socks5_conf;
-                                    socket_client::connect_udp_socks5(
+                        //         async move {
-                                        target,
+                        //             socket_client::connect_udp_socks5(
-                                        bind_addr,
+                        //                 target,
-                                        conf_ref,
+                        //                 bind_addr,
-                                        RENDEZVOUS_TIMEOUT,
+                        //                 conf_ref,
-                                    )
+                        //                 RENDEZVOUS_TIMEOUT,
-                                    .await
+                        //             )
-                                }
+                        //             .await
-                            };
+                        //         }
-                            allow_err!(Self::start(server, host, servers, conn_fn, true).await);
+                        //     };
-                        } else {
+                        //     allow_err!(Self::start(server, host, servers, conn_fn, true).await);
-                            allow_err!(
+                        // } else {
-                                Self::start(
+                        //     allow_err!(
-                                    server,
+                        //         Self::start(
-                                    host,
+                        //             server,
-                                    servers,
+                        //             host,
-                                    socket_client::connect_udp_socket,
+                        //             servers,
-                                    false,
+                        //             socket_client::connect_udp_socket,
-                                )
+                        //             false,
-                                .await
+                        //         )
-                            );
+                        //         .await
-                        }
+                        //     );
+                        // }
                     }));
                 }
                 join_all(futs).await;
@@ -100,19 +97,11 @@ impl RendezvousMediator {
         }
     }
 
-    pub async fn start<'a, F, Fut, Frm>(
+    pub async fn start(
         server: ServerPtr,
         host: String,
         rendezvous_servers: Vec<String>,
-        conn_fn: F,
+    ) -> ResultType<()> {
-        socks5: bool,
-    ) -> ResultType<()>
-    where
-        F: Fn(SocketAddr) -> Fut,
-        Fut: Future<Output = ResultType<(FramedSocket<Frm>, Option<SocketAddr>)>>,
-        Frm: Unpin + Stream<Item = ResultType<(BytesMut, SocketAddr)>> + Sink<(Bytes, SocketAddr)>,
-        <Frm as Sink<(Bytes, SocketAddr)>>::Error: Sync + Send + std::error::Error + 'static,
-    {
         log::info!("start rendezvous mediator of {}", host);
         let host_prefix: String = host
             .split(".")
@@ -132,12 +121,17 @@ impl RendezvousMediator {
             rendezvous_servers,
             last_id_pk_registry: "".to_owned(),
         };
-        allow_err!(rz.dns_check());
+        let mut host_addr = rz.addr;
+        allow_err!(rz.dns_check(&mut host_addr));
 
         let bind_addr = Config::get_any_listen_addr();
-        let (mut socket, target_addr) = conn_fn(bind_addr).await?;
+        let target = format!("{}:{}", host, RENDEZVOUS_PORT);
+        let (mut socket, target_addr) =
+            socket_client::connect_udp(target, bind_addr, RENDEZVOUS_TIMEOUT).await?;
         if let Some(addr) = target_addr {
             rz.addr = addr;
+        } else {
+            rz.addr = host_addr;
         }
         const TIMER_OUT: Duration = Duration::from_secs(1);
         let mut timer = interval(TIMER_OUT);
@@ -254,20 +248,16 @@ impl RendezvousMediator {
                     }
                     if rz.addr.port() == 0 {
                         // tcp is established to help connecting socks5
-                        if !socks5 {
+                        allow_err!(rz.dns_check(&mut host_addr));
-                            allow_err!(rz.dns_check());
+                        if host_addr.port() == 0 {
-                            if rz.addr.port() == 0 {
+                            continue;
-                                continue;
+                        } else {
-                            } else {
+                            // have to do this for osx, to avoid "Can't assign requested address"
-                                // have to do this for osx, to avoid "Can't assign requested address"
+                            // when socket created before OS network ready
-                                // when socket created before OS network ready
+                            if let Some(s) = socket_client::reconnect_udp(bind_addr).await? {
-
+                                socket = s;
-                                let r = conn_fn(bind_addr).await?;
+                                rz.addr = host_addr;
-                                socket = r.0;
+                            };
-                                if let Some(addr) = r.1 {
-                                    rz.addr = addr;
-                                }
-                            }
                         }
                     }
                     let now = SystemTime::now();
@@ -287,18 +277,13 @@ impl RendezvousMediator {
                                 Config::update_latency(&host, -1);
                                 old_latency = 0;
                                 if now.duration_since(last_dns_check).map(|d| d.as_millis() as i64).unwrap_or(0) > DNS_INTERVAL {
-                                    // tcp is established to help connecting socks5
+                                    if let Ok(_) = rz.dns_check(&mut host_addr) {
-                                    if !socks5 {
-                                        if let Ok(_) = rz.dns_check() {
                                         // in some case of network reconnect (dial IP network),
                                         // old UDP socket not work any more after network recover
-
+                                        if let Some(s) = socket_client::reconnect_udp(bind_addr).await? {
-                                            let r = conn_fn(bind_addr).await?;
+                                            socket = s;
-                                            socket = r.0;
+                                            rz.addr = host_addr;
-                                            if let Some(addr) = r.1 {
+                                        };
-                                                rz.addr = addr;
-                                            }
-                                        }
                                     }
                                     last_dns_check = now;
                                 }
@@ -314,8 +299,8 @@ impl RendezvousMediator {
         Ok(())
     }
 
-    fn dns_check(&mut self) -> ResultType<()> {
+    fn dns_check(&self, addr: &mut SocketAddr) -> ResultType<()> {
-        self.addr = hbb_common::to_socket_addr(&crate::check_port(&self.host, RENDEZVOUS_PORT))?;
+        *addr = hbb_common::to_socket_addr(&crate::check_port(&self.host, RENDEZVOUS_PORT))?;
         log::debug!("Lookup dns of {}", self.host);
         Ok(())
     }
@@ -449,11 +434,7 @@ impl RendezvousMediator {
         Ok(())
     }
 
-    async fn register_pk<Frm>(&mut self, socket: &mut FramedSocket<Frm>) -> ResultType<()>
+    async fn register_pk(&mut self, socket: &mut FramedSocket) -> ResultType<()> {
-    where
-        Frm: Unpin + Stream + Sink<(Bytes, SocketAddr)>,
-        <Frm as Sink<(Bytes, SocketAddr)>>::Error: Sync + Send + std::error::Error + 'static,
-    {
         let mut msg_out = Message::new();
         let pk = Config::get_key_pair().1;
         let uuid = if let Ok(id) = machine_uid::get() {
@@ -474,11 +455,7 @@ impl RendezvousMediator {
         Ok(())
     }
 
-    async fn handle_uuid_mismatch<Frm>(&mut self, socket: &mut FramedSocket<Frm>) -> ResultType<()>
+    async fn handle_uuid_mismatch(&mut self, socket: &mut FramedSocket) -> ResultType<()> {
-    where
-        Frm: Unpin + Stream + Sink<(Bytes, SocketAddr)>,
-        <Frm as Sink<(Bytes, SocketAddr)>>::Error: Sync + Send + std::error::Error + 'static,
-    {
         if self.last_id_pk_registry != Config::get_id() {
             return Ok(());
         }
@@ -496,11 +473,7 @@ impl RendezvousMediator {
         self.register_pk(socket).await
     }
 
-    async fn register_peer<Frm>(&mut self, socket: &mut FramedSocket<Frm>) -> ResultType<()>
+    async fn register_peer(&mut self, socket: &mut FramedSocket) -> ResultType<()> {
-    where
-        Frm: Unpin + Stream + Sink<(Bytes, SocketAddr)>,
-        <Frm as Sink<(Bytes, SocketAddr)>>::Error: Sync + Send + std::error::Error + 'static,
-    {
         if !SOLVING_PK_MISMATCH.lock().unwrap().is_empty() {
             return Ok(());
         }