TheLanc3/rustdesk
1
0
Fork 0
mirror of https://github.com/rustdesk/rustdesk.git synced 2026-03-13 16:21:06 +03:00
Code Issues 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
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 std::net::SocketAddr;
use std::net::ToSocketAddrs;
use tokio::net::ToSocketAddrs;
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 {
let mut host = host.to_owned();
if !host.contains(":") {
host = format!("{}:{}", host, 0);
}
use std::net::ToSocketAddrs;
match Config::get_network_type() {
NetworkType::Direct => match to_socket_addr(&host) {
NetworkType::Direct => match host.to_socket_addrs() {
Err(err) => err.to_string(),
Ok(_) => "".to_owned(),
},
@@ -54,56 +28,51 @@ pub fn test_if_valid_server(host: &str) -> String {
}
}
pub trait IntoTargetAddr2<'a> {
/// Converts the value of self to a `TargetAddr`.
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>>;
pub trait IsResolvedSocketAddr {
fn resolve(&self) -> Option<&SocketAddr>;
}
impl<'a> IntoTargetAddr2<'a> for SocketAddr {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> {
Ok(TargetAddr::Ip(*self))
impl IsResolvedSocketAddr for SocketAddr {
fn resolve(&self) -> Option<&SocketAddr> {
Some(&self)
}
}
impl<'a> IntoTargetAddr2<'a> for TargetAddr<'a> {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> {
Ok(self.clone())
impl IsResolvedSocketAddr for String {
fn resolve(&self) -> Option<&SocketAddr> {
None
}
}
impl<'a> IntoTargetAddr2<'a> for String {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> {
Ok(to_socket_addr(self)?.into_target_addr()?)
impl IsResolvedSocketAddr for &str {
fn resolve(&self) -> Option<&SocketAddr> {
None
}
}
impl<'a> IntoTargetAddr2<'a> for &str {
fn into_target_addr2(&self) -> ResultType<TargetAddr<'a>> {
Ok(to_socket_addr(self)?.into_target_addr()?)
}
}
pub async fn connect_tcp<'t, T: IntoTargetAddr2<'t> + std::fmt::Debug>(
#[inline]
pub async fn connect_tcp<
't,
T: IntoTargetAddr<'t> + ToSocketAddrs + IsResolvedSocketAddr + std::fmt::Display,
>(
target: T,
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))
connect_tcp_local(target, None, ms_timeout).await
}
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,
local: SocketAddr,
local: Option<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(),
target_addr,
target,
local,
conf.username.as_str(),
conf.password.as_str(),
@@ -111,13 +80,15 @@ pub async fn connect_tcp_local<'t, T: IntoTargetAddr<'t> + std::fmt::Debug>(
)
.await;
}
let mut addr = ToSocketAddrs::to_socket_addrs(&target_addr)?
.next()
.context(format!("Invalid target addr: {:?}", target_addr))?;
if local.is_ipv6() && addr.is_ipv4() {
addr = query_nip_io(&addr)?;
if let Some(target) = target.resolve() {
if let Some(local) = local {
if local.is_ipv6() && target.is_ipv4() {
let target = query_nip_io(&target).await?;
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]
@@ -129,8 +100,12 @@ pub fn is_ipv4(target: &TargetAddr<'_>) -> bool {
}
#[inline]
pub fn query_nip_io(addr: &SocketAddr) -> ResultType<SocketAddr> {
to_socket_addr(format!("{}.nip.io:{}", addr.ip(), addr.port()))
pub async fn query_nip_io(addr: &SocketAddr) -> ResultType<SocketAddr> {
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]
@@ -143,17 +118,29 @@ pub fn ipv4_to_ipv6(addr: String, ipv4: bool) -> String {
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 test_is_ipv4(target: &str) -> bool {
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> {
match Config::get_socks() {
None => Ok(FramedSocket::new(to_socket_addr(&local)?).await?),
None => Ok(FramedSocket::new(local).await?),
Some(conf) => {
let socket = FramedSocket::new_proxy(
conf.proxy.as_str(),
to_socket_addr(local)?,
local,
conf.username.as_str(),
conf.password.as_str(),
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() {
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),
}
@@ -175,19 +162,17 @@ pub async fn rebind_udp_for(target: &TargetAddr<'_>) -> ResultType<Option<Framed
#[cfg(test)]
mod tests {
use std::net::ToSocketAddrs;
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]
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(), false), "1.1.1.1.nip.io");
assert_eq!(
@@ -198,15 +183,19 @@ mod tests {
ipv4_to_ipv6("rustdesk.com".to_owned(), false),
"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())
.await
.unwrap()
.is_ipv6());
return;
}
assert_eq!(
query_nip_io(&"1.1.1.1:80".parse().unwrap()).unwrap(),
"1.1.1.1:80".parse().unwrap()
);
assert!(query_nip_io(&"1.1.1.1:80".parse().unwrap()).await.is_err());
}
}