hongshaorou/rustdesk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix nat64 and refactor ipv6

Browse Source
This commit is contained in:
rustdesk 2022-12-29 20:34:52 +08:00
parent 3bd48cd087
commit 67ad937fdd
7 changed files with 157 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
libs/hbb_common/src/socket_client.rs
View File

@ -6,44 +6,18 @@ use crate::{
}; };
use anyhow::Context; use anyhow::Context;
use std::net::SocketAddr; use std::net::SocketAddr;
use std::net::ToSocketAddrs; use tokio::net::ToSocketAddrs;
use tokio_socks::{IntoTargetAddr, TargetAddr}; use tokio_socks::{IntoTargetAddr, TargetAddr};
fn to_socket_addr<T: ToSocketAddrs>(host: T) -> ResultType<SocketAddr> {
let mut addr_ipv4 = None;
let mut addr_ipv6 = None;
for addr in host.to_socket_addrs()? {
if addr.is_ipv4() && addr_ipv4.is_none() {
addr_ipv4 = Some(addr);
}
if addr.is_ipv6() && addr_ipv6.is_none() {
addr_ipv6 = Some(addr);
}
}
if let Some(addr) = addr_ipv4 {
Ok(addr)
} else {
addr_ipv6.context("Failed to solve")
}
}
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 { pub fn test_if_valid_server(host: &str) -> String {
let mut host = host.to_owned(); let mut host = host.to_owned();
if !host.contains(":") { if !host.contains(":") {
host = format!("{}:{}", host, 0); host = format!("{}:{}", host, 0);
} }
use std::net::ToSocketAddrs;
match Config::get_network_type() { match Config::get_network_type() {
NetworkType::Direct => match to_socket_addr(&host) { NetworkType::Direct => match host.to_socket_addrs() {
Err(err) => err.to_string(), Err(err) => err.to_string(),
Ok(_) => "".to_owned(), Ok(_) => "".to_owned(),
}, },
@ -54,56 +28,51 @@ pub fn test_if_valid_server(host: &str) -> String {
} }
} }
pub trait IntoTargetAddr2<'a> { pub trait IsResolvedSocketAddr {
/// Converts the value of self to a `TargetAddr`. fn resolve(&self) -> Option<&SocketAddr>;
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>>;
} }
impl<'a> IntoTargetAddr2<'a> for SocketAddr { impl IsResolvedSocketAddr for SocketAddr {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> { fn resolve(&self) -> Option<&SocketAddr> {
Ok(TargetAddr::Ip(*self)) Some(&self)
} }
} }
impl<'a> IntoTargetAddr2<'a> for TargetAddr<'a> { impl IsResolvedSocketAddr for String {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> { fn resolve(&self) -> Option<&SocketAddr> {
Ok(self.clone()) None
} }
} }
impl<'a> IntoTargetAddr2<'a> for String { impl IsResolvedSocketAddr for &str {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> { fn resolve(&self) -> Option<&SocketAddr> {
Ok(to_socket_addr(self)?.into_target_addr()?) None
} }
} }
impl<'a> IntoTargetAddr2<'a> for &str { #[inline]
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> { pub async fn connect_tcp<
Ok(to_socket_addr(self)?.into_target_addr()?) 't,
} T: IntoTargetAddr<'t> + ToSocketAddrs + IsResolvedSocketAddr + std::fmt::Display,
} >(
pub async fn connect_tcp<'t, T: IntoTargetAddr2<'t> + std::fmt::Debug>(
target: T, target: T,
ms_timeout: u64, ms_timeout: u64,
) -> ResultType<FramedStream> { ) -> ResultType<FramedStream> {
let target_addr = target.into_target_addr2()?; connect_tcp_local(target, None, ms_timeout).await
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>( pub async fn connect_tcp_local<
't,
T: IntoTargetAddr<'t> + ToSocketAddrs + IsResolvedSocketAddr + std::fmt::Display,
>(
target: T, target: T,
local: SocketAddr, local: Option<SocketAddr>,
ms_timeout: u64, ms_timeout: u64,
) -> ResultType<FramedStream> { ) -> ResultType<FramedStream> {
let target_addr = target.into_target_addr()?;
if let Some(conf) = Config::get_socks() { if let Some(conf) = Config::get_socks() {
return FramedStream::connect( return FramedStream::connect(
conf.proxy.as_str(), conf.proxy.as_str(),
target_addr, target,
local, local,
conf.username.as_str(), conf.username.as_str(),
conf.password.as_str(), conf.password.as_str(),
@ -111,13 +80,15 @@ pub async fn connect_tcp_local<'t, T: IntoTargetAddr<'t> + std::fmt::Debug>(
) )
.await; .await;
} }
let mut addr = ToSocketAddrs::to_socket_addrs(&target_addr)? if let Some(target) = target.resolve() {
.next() if let Some(local) = local {
.context(format!("Invalid target addr: {:?}", target_addr))?; if local.is_ipv6() && target.is_ipv4() {
if local.is_ipv6() && addr.is_ipv4() { let target = query_nip_io(&target).await?;
addr = query_nip_io(&addr)?; return Ok(FramedStream::new(target, Some(local), ms_timeout).await?);
} }
Ok(FramedStream::new(addr, local, ms_timeout).await?) }
}
Ok(FramedStream::new(target, local, ms_timeout).await?)
} }
#[inline] #[inline]
@ -129,8 +100,12 @@ pub fn is_ipv4(target: &TargetAddr<'_>) -> bool {
} }
#[inline] #[inline]
pub fn query_nip_io(addr: &SocketAddr) -> ResultType<SocketAddr> { pub async fn query_nip_io(addr: &SocketAddr) -> ResultType<SocketAddr> {
to_socket_addr(format!("{}.nip.io:{}", addr.ip(), addr.port())) tokio::net::lookup_host(format!("{}.nip.io:{}", addr.ip(), addr.port()))
.await?
.filter(|x| x.is_ipv6())
.next()
.context("Failed to get ipv6 from nip.io")
} }
#[inline] #[inline]
@ -143,17 +118,29 @@ pub fn ipv4_to_ipv6(addr: String, ipv4: bool) -> String {
addr addr
} }
pub async fn new_udp_for(target: &TargetAddr<'_>, ms_timeout: u64) -> ResultType<FramedSocket> { async fn test_is_ipv4(target: &str) -> bool {
new_udp(Config::get_any_listen_addr(is_ipv4(target)), ms_timeout).await if let Ok(Ok(s)) = super::timeout(1000, tokio::net::TcpStream::connect(target)).await {
return s.local_addr().map(|x| x.is_ipv4()).unwrap_or(true);
}
true
}
#[inline]
pub async fn new_udp_for(target: &str, ms_timeout: u64) -> ResultType<FramedSocket> {
new_udp(
Config::get_any_listen_addr(test_is_ipv4(target).await),
ms_timeout,
)
.await
} }
async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<FramedSocket> { async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<FramedSocket> {
match Config::get_socks() { match Config::get_socks() {
None => Ok(FramedSocket::new(to_socket_addr(&local)?).await?), None => Ok(FramedSocket::new(local).await?),
Some(conf) => { Some(conf) => {
let socket = FramedSocket::new_proxy( let socket = FramedSocket::new_proxy(
conf.proxy.as_str(), conf.proxy.as_str(),
to_socket_addr(local)?, local,
conf.username.as_str(), conf.username.as_str(),
conf.password.as_str(), conf.password.as_str(),
ms_timeout, ms_timeout,
@ -164,10 +151,10 @@ async fn new_udp<T: ToSocketAddrs>(local: T, ms_timeout: u64) -> ResultType<Fram
} }
} }
pub async fn rebind_udp_for(target: &TargetAddr<'_>) -> ResultType<Option<FramedSocket>> { pub async fn rebind_udp_for(target: &str) -> ResultType<Option<FramedSocket>> {
match Config::get_network_type() { match Config::get_network_type() {
NetworkType::Direct => Ok(Some( NetworkType::Direct => Ok(Some(
FramedSocket::new(Config::get_any_listen_addr(is_ipv4(target))).await?, FramedSocket::new(Config::get_any_listen_addr(test_is_ipv4(target).await)).await?,
)), )),
_ => Ok(None), _ => Ok(None),
} }
@ -175,19 +162,17 @@ pub async fn rebind_udp_for(target: &TargetAddr<'_>) -> ResultType<Option<Framed
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::net::ToSocketAddrs;
use super::*; 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!(to_socket_addr("[ff::]:0").unwrap().is_ipv6());
assert!(to_socket_addr("xx").is_err());
}
#[test] #[test]
fn test_nat64() { fn test_nat64() {
test_nat64_async();
}
#[tokio::main(flavor = "current_thread")]
async fn test_nat64_async() {
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(), 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".to_owned(), false), "1.1.1.1.nip.io");
assert_eq!( assert_eq!(
@ -198,15 +183,19 @@ mod tests {
ipv4_to_ipv6("rustdesk.com".to_owned(), false), ipv4_to_ipv6("rustdesk.com".to_owned(), false),
"rustdesk.com" "rustdesk.com"
); );
if to_socket_addr("rustdesk.com:80").unwrap().is_ipv6() { if ("rustdesk.com:80")
.to_socket_addrs()
.unwrap()
.next()
.unwrap()
.is_ipv6()
{
assert!(query_nip_io(&"1.1.1.1:80".parse().unwrap()) assert!(query_nip_io(&"1.1.1.1:80".parse().unwrap())
.await
.unwrap() .unwrap()
.is_ipv6()); .is_ipv6());
return; return;
} }
assert_eq!( assert!(query_nip_io(&"1.1.1.1:80".parse().unwrap()).await.is_err());
query_nip_io(&"1.1.1.1:80".parse().unwrap()).unwrap(),
"1.1.1.1:80".parse().unwrap()
);
} }
} }

46
libs/hbb_common/src/tcp.rs
View File

@ -73,18 +73,21 @@ fn new_socket(addr: std::net::SocketAddr, reuse: bool) -> Result<TcpSocket, std:
} }
impl FramedStream { impl FramedStream {
pub async fn new<T1: ToSocketAddrs, T2: ToSocketAddrs>( pub async fn new<T: ToSocketAddrs + std::fmt::Display>(
remote_addr: T1, remote_addr: T,
local_addr: T2, local_addr: Option<SocketAddr>,
ms_timeout: u64, ms_timeout: u64,
) -> ResultType<Self> { ) -> ResultType<Self> {
for local_addr in lookup_host(&local_addr).await? {
for remote_addr in lookup_host(&remote_addr).await? { for remote_addr in lookup_host(&remote_addr).await? {
let stream = super::timeout( let local = if let Some(addr) = local_addr {
ms_timeout, addr
new_socket(local_addr, true)?.connect(remote_addr), } else {
) crate::config::Config::get_any_listen_addr(remote_addr.is_ipv4())
.await??; };
if let Ok(socket) = new_socket(local, true) {
if let Ok(Ok(stream)) =
super::timeout(ms_timeout, socket.connect(remote_addr)).await
{
stream.set_nodelay(true).ok(); stream.set_nodelay(true).ok();
let addr = stream.local_addr()?; let addr = stream.local_addr()?;
return Ok(Self( return Ok(Self(
@ -95,26 +98,30 @@ impl FramedStream {
)); ));
} }
} }
bail!("could not resolve to any address"); }
bail!(format!("Failed to connect to {}", remote_addr));
} }
pub async fn connect<'a, 't, P, T1, T2>( pub async fn connect<'a, 't, P, T>(
proxy: P, proxy: P,
target: T1, target: T,
local: T2, local_addr: Option<SocketAddr>,
username: &'a str, username: &'a str,
password: &'a str, password: &'a str,
ms_timeout: u64, ms_timeout: u64,
) -> ResultType<Self> ) -> ResultType<Self>
where where
P: ToProxyAddrs, P: ToProxyAddrs,
T1: IntoTargetAddr<'t>, T: IntoTargetAddr<'t>,
T2: ToSocketAddrs,
{ {
if let Some(local) = lookup_host(&local).await?.next() { if let Some(Ok(proxy)) = proxy.to_proxy_addrs().next().await {
if let Some(proxy) = proxy.to_proxy_addrs().next().await { let local = if let Some(addr) = local_addr {
addr
} else {
crate::config::Config::get_any_listen_addr(proxy.is_ipv4())
};
let stream = let stream =
super::timeout(ms_timeout, new_socket(local, true)?.connect(proxy?)).await??; super::timeout(ms_timeout, new_socket(local, true)?.connect(proxy)).await??;
stream.set_nodelay(true).ok(); stream.set_nodelay(true).ok();
let stream = if username.trim().is_empty() { let stream = if username.trim().is_empty() {
super::timeout( super::timeout(
@ -138,8 +145,7 @@ impl FramedStream {
None, None,
0, 0,
)); ));
}; }
};
bail!("could not resolve to any address"); bail!("could not resolve to any address");
} }

9
libs/hbb_common/src/udp.rs
View File

@ -164,4 +164,13 @@ impl FramedSocket {
None None
} }
} }
pub fn is_ipv4(&self) -> bool {
if let FramedSocket::Direct(x) = self {
if let Ok(v) = x.get_ref().local_addr() {
return v.is_ipv4();
}
}
true
}
} }

2
src/cli.rs
View File

@ -102,6 +102,8 @@ pub async fn connect_test(
handler, handler,
).await { ).await {
log::error!("Failed to connect {}: {}", &id, err); log::error!("Failed to connect {}: {}", &id, err);
} else {
// rpassword::prompt_password("Input anything to exit").ok();
} }
} }

2
src/client.rs
View File

@ -376,7 +376,7 @@ impl Client {
log::info!("peer address: {}, timeout: {}", peer, connect_timeout); log::info!("peer address: {}, timeout: {}", peer, connect_timeout);
let start = std::time::Instant::now(); let start = std::time::Instant::now();
// NOTICE: Socks5 is be used event in intranet. Which may be not a good way. // NOTICE: Socks5 is be used event in intranet. Which may be not a good way.
let mut conn = socket_client::connect_tcp_local(peer, local_addr, connect_timeout).await; let mut conn = socket_client::connect_tcp_local(peer, Some(local_addr), connect_timeout).await;
let mut direct = !conn.is_err(); let mut direct = !conn.is_err();
if interface.is_force_relay() || conn.is_err() { if interface.is_force_relay() || conn.is_err() {
if !relay_server.is_empty() { if !relay_server.is_empty() {

11
src/common.rs
View File

@ -310,15 +310,9 @@ async fn test_nat_type_() -> ResultType<bool> {
}); });
let mut port1 = 0; let mut port1 = 0;
let mut port2 = 0; let mut port2 = 0;
let server1 = socket_client::get_target_addr(&server1)?;
let server2 = socket_client::get_target_addr(&server2)?;
for i in 0..2 { for i in 0..2 {
let mut socket = socket_client::connect_tcp( let mut socket = socket_client::connect_tcp(
if i == 0 { if i == 0 { &*server1 } else { &*server2 },
server1.clone()
} else {
server2.clone()
},
RENDEZVOUS_TIMEOUT, RENDEZVOUS_TIMEOUT,
) )
.await?; .await?;
@ -525,8 +519,7 @@ pub fn check_software_update() {
async fn check_software_update_() -> hbb_common::ResultType<()> { async fn check_software_update_() -> hbb_common::ResultType<()> {
sleep(3.).await; sleep(3.).await;
let rendezvous_server = let rendezvous_server = format!("rs-sg.rustdesk.com:{}", config::RENDEZVOUS_PORT);
socket_client::get_target_addr(&format!("rs-sg.rustdesk.com:{}", config::RENDEZVOUS_PORT))?;
let mut socket = socket_client::new_udp_for(&rendezvous_server, RENDEZVOUS_TIMEOUT).await?; let mut socket = socket_client::new_udp_for(&rendezvous_server, RENDEZVOUS_TIMEOUT).await?;
let mut msg_out = RendezvousMessage::new(); let mut msg_out = RendezvousMessage::new();

20
src/rendezvous_mediator.rs
View File

@ -38,10 +38,11 @@ static SHOULD_EXIT: AtomicBool = AtomicBool::new(false);
#[derive(Clone)] #[derive(Clone)]
pub struct RendezvousMediator { pub struct RendezvousMediator {
addr: TargetAddr<'static>, addr: String,
host: String, host: String,
host_prefix: String, host_prefix: String,
last_id_pk_registry: String, last_id_pk_registry: String,
is_ipv4: bool,
} }
impl RendezvousMediator { impl RendezvousMediator {
@ -111,13 +112,15 @@ impl RendezvousMediator {
}) })
.unwrap_or(host.to_owned()); .unwrap_or(host.to_owned());
let mut rz = Self { let mut rz = Self {
addr: socket_client::get_target_addr(&crate::check_port(&host, RENDEZVOUS_PORT))?, addr: crate::check_port(&host, RENDEZVOUS_PORT),
is_ipv4: false,
host: host.clone(), host: host.clone(),
host_prefix, host_prefix,
last_id_pk_registry: "".to_owned(), last_id_pk_registry: "".to_owned(),
}; };
let mut socket = socket_client::new_udp_for(&rz.addr, RENDEZVOUS_TIMEOUT).await?; let mut socket = socket_client::new_udp_for(&rz.addr, RENDEZVOUS_TIMEOUT).await?;
rz.is_ipv4 = socket.is_ipv4();
const TIMER_OUT: Duration = Duration::from_secs(1); const TIMER_OUT: Duration = Duration::from_secs(1);
let mut timer = interval(TIMER_OUT); let mut timer = interval(TIMER_OUT);
@ -248,11 +251,11 @@ impl RendezvousMediator {
Config::update_latency(&host, -1); Config::update_latency(&host, -1);
old_latency = 0; old_latency = 0;
if last_dns_check.elapsed().as_millis() as i64 > DNS_INTERVAL { if last_dns_check.elapsed().as_millis() as i64 > DNS_INTERVAL {
rz.addr = socket_client::get_target_addr(&crate::check_port(&host, RENDEZVOUS_PORT))?;
// in some case of network reconnect (dial IP network), // in some case of network reconnect (dial IP network),
// old UDP socket not work any more after network recover // old UDP socket not work any more after network recover
if let Some(s) = socket_client::rebind_udp_for(&rz.addr).await? { if let Some(s) = socket_client::rebind_udp_for(&rz.addr).await? {
socket = s; socket = s;
rz.is_ipv4 = socket.is_ipv4();
} }
last_dns_check = Instant::now(); last_dns_check = Instant::now();
} }
@ -314,14 +317,14 @@ impl RendezvousMediator {
} }
msg_out.set_relay_response(rr); msg_out.set_relay_response(rr);
socket.send(&msg_out).await?; socket.send(&msg_out).await?;
let v4 = socket_client::is_ipv4(&self.addr); crate::create_relay_connection(server, relay_server, uuid, peer_addr, secure, self.is_ipv4)
crate::create_relay_connection(server, relay_server, uuid, peer_addr, secure, v4).await; .await;
Ok(()) Ok(())
} }
async fn handle_intranet(&self, fla: FetchLocalAddr, server: ServerPtr) -> ResultType<()> { async fn handle_intranet(&self, fla: FetchLocalAddr, server: ServerPtr) -> ResultType<()> {
let relay_server = self.get_relay_server(fla.relay_server); let relay_server = self.get_relay_server(fla.relay_server);
if !socket_client::is_ipv4(&self.addr) { if !self.is_ipv4 {
// nat64, go relay directly, because current hbbs will crash if demangle ipv6 address // nat64, go relay directly, because current hbbs will crash if demangle ipv6 address
let uuid = Uuid::new_v4().to_string(); let uuid = Uuid::new_v4().to_string();
return self return self
@ -382,7 +385,7 @@ impl RendezvousMediator {
let local_addr = socket.local_addr(); let local_addr = socket.local_addr();
// key important here for punch hole to tell my gateway incoming peer is safe. // key important here for punch hole to tell my gateway incoming peer is safe.
// it can not be async here, because local_addr can not be reused, we must close the connection before use it again. // it can not be async here, because local_addr can not be reused, we must close the connection before use it again.
allow_err!(socket_client::connect_tcp_local(peer_addr, local_addr, 30).await); allow_err!(socket_client::connect_tcp_local(peer_addr, Some(local_addr), 30).await);
socket socket
}; };
let mut msg_out = Message::new(); let mut msg_out = Message::new();
@ -655,8 +658,7 @@ async fn create_online_stream() -> ResultType<FramedStream> {
bail!("Invalid server address: {}", rendezvous_server); bail!("Invalid server address: {}", rendezvous_server);
} }
let online_server = format!("{}:{}", tmp[0], port - 1); let online_server = format!("{}:{}", tmp[0], port - 1);
let server_addr = socket_client::get_target_addr(&online_server)?; socket_client::connect_tcp(online_server, RENDEZVOUS_TIMEOUT).await
socket_client::connect_tcp(server_addr, RENDEZVOUS_TIMEOUT).await
} }
async fn query_online_states_( async fn query_online_states_(