370 lines
12 KiB
Rust
370 lines
12 KiB
Rust
use std::{
|
|
net::{SocketAddr, ToSocketAddrs, UdpSocket},
|
|
time::Duration,
|
|
};
|
|
|
|
use socket2::{Domain, Protocol, Socket, Type};
|
|
|
|
use crate::{
|
|
config::{ClientConfig, SocketConfig, DEFAULT_PORT, MIN_OPEN_TIMEOUT},
|
|
error::ClientError,
|
|
receive::configure_receive_metadata,
|
|
socket_options::apply_ttl_to_socket,
|
|
};
|
|
|
|
pub(crate) fn validate_open_timeouts(timeouts: &[Duration]) -> Result<(), ClientError> {
|
|
if timeouts.is_empty() {
|
|
return Err(ClientError::NoOpenTimeouts);
|
|
}
|
|
for timeout in timeouts {
|
|
if *timeout < MIN_OPEN_TIMEOUT {
|
|
return Err(ClientError::OpenTimeoutTooSmall {
|
|
timeout: *timeout,
|
|
minimum: MIN_OPEN_TIMEOUT,
|
|
});
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn resolve_remote(config: &ClientConfig) -> Result<SocketAddr, ClientError> {
|
|
#[cfg(all(test, feature = "tokio"))]
|
|
SYNC_RESOLVER_CALLS.with(|calls| calls.set(calls.get() + 1));
|
|
|
|
let addr = normalize_server_addr(&config.server_addr);
|
|
let mut addrs = addr
|
|
.to_socket_addrs()
|
|
.map_err(|_| ClientError::Resolve { addr: addr.clone() })?;
|
|
addrs
|
|
.find(|addr| address_family_allowed(config, *addr))
|
|
.ok_or(ClientError::Resolve { addr })
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
pub(crate) async fn resolve_remote_tokio(config: &ClientConfig) -> Result<SocketAddr, ClientError> {
|
|
let addr = normalize_server_addr(&config.server_addr);
|
|
if let Ok(remote) = addr.parse::<SocketAddr>() {
|
|
return address_family_allowed(config, remote)
|
|
.then_some(remote)
|
|
.ok_or(ClientError::Resolve { addr });
|
|
}
|
|
|
|
#[cfg(all(test, feature = "tokio"))]
|
|
TOKIO_DNS_LOOKUPS.with(|calls| calls.set(calls.get() + 1));
|
|
|
|
let mut addrs = tokio::net::lookup_host(&addr)
|
|
.await
|
|
.map_err(|_| ClientError::Resolve { addr: addr.clone() })?;
|
|
addrs
|
|
.find(|remote| address_family_allowed(config, *remote))
|
|
.ok_or_else(|| ClientError::Resolve { addr: addr.clone() })
|
|
}
|
|
|
|
fn address_family_allowed(config: &ClientConfig, remote: SocketAddr) -> bool {
|
|
(!config.socket_config.ipv4_only || remote.is_ipv4())
|
|
&& (!config.socket_config.ipv6_only || remote.is_ipv6())
|
|
}
|
|
|
|
#[cfg(all(test, feature = "tokio"))]
|
|
std::thread_local! {
|
|
static SYNC_RESOLVER_CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
|
static TOKIO_DNS_LOOKUPS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
|
}
|
|
|
|
#[cfg(all(test, feature = "tokio"))]
|
|
pub(crate) fn resolution_call_counts() -> (usize, usize) {
|
|
(
|
|
SYNC_RESOLVER_CALLS.with(std::cell::Cell::get),
|
|
TOKIO_DNS_LOOKUPS.with(std::cell::Cell::get),
|
|
)
|
|
}
|
|
|
|
pub(crate) fn normalize_server_addr(addr: &str) -> String {
|
|
if addr.parse::<SocketAddr>().is_ok() {
|
|
return addr.to_owned();
|
|
}
|
|
if addr.starts_with('[') && addr.ends_with(']') {
|
|
return format!("{addr}:{DEFAULT_PORT}");
|
|
}
|
|
if addr.starts_with('[') {
|
|
return addr.to_owned();
|
|
}
|
|
if addr.parse::<std::net::Ipv6Addr>().is_ok() {
|
|
return format!("[{addr}]:{DEFAULT_PORT}");
|
|
}
|
|
if addr
|
|
.rsplit_once(':')
|
|
.is_some_and(|(_, port)| port.parse::<u16>().is_ok())
|
|
{
|
|
return addr.to_owned();
|
|
}
|
|
format!("{addr}:{DEFAULT_PORT}")
|
|
}
|
|
|
|
pub(crate) fn connect_udp_socket(
|
|
config: &SocketConfig,
|
|
remote: SocketAddr,
|
|
) -> Result<UdpSocket, ClientError> {
|
|
let socket = create_connected_udp_socket(config, remote)?;
|
|
socket.set_read_timeout(config.recv_timeout)?;
|
|
Ok(socket)
|
|
}
|
|
|
|
fn create_connected_udp_socket(
|
|
config: &SocketConfig,
|
|
remote: SocketAddr,
|
|
) -> Result<UdpSocket, ClientError> {
|
|
let socket = create_prebind_udp_socket(config, remote)?;
|
|
let bind_addr = config.bind_addr.unwrap_or_else(|| {
|
|
if remote.is_ipv4() {
|
|
SocketAddr::from(([0, 0, 0, 0], 0))
|
|
} else {
|
|
SocketAddr::from(([0_u16; 8], 0))
|
|
}
|
|
});
|
|
socket.bind(&bind_addr.into())?;
|
|
socket.connect(&remote.into())?;
|
|
|
|
let socket: UdpSocket = socket.into();
|
|
configure_receive_metadata(&socket, remote).map_err(|source| ClientError::SocketOption {
|
|
operation: "enable receive metadata",
|
|
remote,
|
|
source,
|
|
})?;
|
|
if let Some(ttl) = config.ttl {
|
|
apply_ttl_to_socket(&socket, remote, ttl)?;
|
|
}
|
|
Ok(socket)
|
|
}
|
|
|
|
fn create_prebind_udp_socket(
|
|
config: &SocketConfig,
|
|
remote: SocketAddr,
|
|
) -> Result<Socket, ClientError> {
|
|
let domain = if remote.is_ipv4() {
|
|
Domain::IPV4
|
|
} else {
|
|
Domain::IPV6
|
|
};
|
|
let socket = Socket::new(domain, Type::DGRAM, Some(Protocol::UDP))?;
|
|
|
|
if config.ipv6_only && remote.is_ipv6() {
|
|
socket.set_only_v6(true)?;
|
|
}
|
|
Ok(socket)
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
pub(crate) fn connect_tokio_udp_socket(
|
|
config: &SocketConfig,
|
|
remote: SocketAddr,
|
|
) -> Result<tokio::net::UdpSocket, ClientError> {
|
|
let socket = create_connected_udp_socket(config, remote)?;
|
|
socket.set_nonblocking(true)?;
|
|
Ok(tokio::net::UdpSocket::from_std(socket)?)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn normalize_server_addr_adds_default_ports() {
|
|
assert_eq!(normalize_server_addr("127.0.0.1"), "127.0.0.1:2112");
|
|
assert_eq!(normalize_server_addr("127.0.0.1:1234"), "127.0.0.1:1234");
|
|
assert_eq!(normalize_server_addr("localhost"), "localhost:2112");
|
|
assert_eq!(normalize_server_addr("localhost:1234"), "localhost:1234");
|
|
assert_eq!(normalize_server_addr("::1"), "[::1]:2112");
|
|
assert_eq!(normalize_server_addr("[::1]"), "[::1]:2112");
|
|
assert_eq!(normalize_server_addr("[::1]:1234"), "[::1]:1234");
|
|
}
|
|
|
|
#[test]
|
|
fn address_family_filtering_remains_unchanged() {
|
|
let ipv4 = SocketAddr::from(([127, 0, 0, 1], DEFAULT_PORT));
|
|
let ipv6 = SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 1], DEFAULT_PORT));
|
|
let mut config = ClientConfig::default();
|
|
|
|
assert!(address_family_allowed(&config, ipv4));
|
|
assert!(address_family_allowed(&config, ipv6));
|
|
|
|
config.socket_config.ipv4_only = true;
|
|
assert!(address_family_allowed(&config, ipv4));
|
|
assert!(!address_family_allowed(&config, ipv6));
|
|
|
|
config.socket_config.ipv4_only = false;
|
|
config.socket_config.ipv6_only = true;
|
|
assert!(!address_family_allowed(&config, ipv4));
|
|
assert!(address_family_allowed(&config, ipv6));
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_ipv6_only_is_applied_before_bind() {
|
|
let config = SocketConfig {
|
|
ipv6_only: true,
|
|
..SocketConfig::default()
|
|
};
|
|
let remote = SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 1], DEFAULT_PORT));
|
|
|
|
let socket = create_prebind_udp_socket(&config, remote).unwrap();
|
|
|
|
assert!(socket.only_v6().unwrap());
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_ipv6_socket_preserves_v6only_and_explicit_bind() {
|
|
let bind_addr = SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 1], 0));
|
|
let peer = match UdpSocket::bind(bind_addr) {
|
|
Ok(peer) => peer,
|
|
Err(error) if ipv6_loopback_unavailable(&error) => {
|
|
eprintln!("skipping IPv6 Tokio socket test: IPv6 loopback unavailable: {error}");
|
|
return;
|
|
}
|
|
Err(error) => panic!("{error}"),
|
|
};
|
|
let remote = peer.local_addr().unwrap();
|
|
let config = SocketConfig {
|
|
bind_addr: Some(bind_addr),
|
|
ipv6_only: true,
|
|
..SocketConfig::default()
|
|
};
|
|
|
|
tokio_runtime().block_on(async {
|
|
let socket = connect_tokio_udp_socket(&config, remote).unwrap();
|
|
|
|
assert!(socket2::SockRef::from(&socket).only_v6().unwrap());
|
|
assert!(socket.local_addr().unwrap().is_ipv6());
|
|
assert_eq!(socket.local_addr().unwrap().ip(), bind_addr.ip());
|
|
assert_eq!(socket.peer_addr().unwrap(), remote);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_ipv4_socket_preserves_family_bind_peer_and_ttl() {
|
|
let peer = UdpSocket::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
|
|
let remote = peer.local_addr().unwrap();
|
|
let bind_addr = SocketAddr::from(([127, 0, 0, 1], 0));
|
|
let config = SocketConfig {
|
|
bind_addr: Some(bind_addr),
|
|
ttl: Some(64),
|
|
..SocketConfig::default()
|
|
};
|
|
|
|
tokio_runtime().block_on(async {
|
|
let socket = connect_tokio_udp_socket(&config, remote).unwrap();
|
|
|
|
assert!(socket.local_addr().unwrap().is_ipv4());
|
|
assert_eq!(socket.local_addr().unwrap().ip(), bind_addr.ip());
|
|
assert_eq!(socket.peer_addr().unwrap(), remote);
|
|
assert_eq!(socket2::SockRef::from(&socket).ttl_v4().unwrap(), 64);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_resolver_filters_families_without_using_blocking_resolution() {
|
|
let mut config = ClientConfig {
|
|
server_addr: "localhost:2112".to_owned(),
|
|
..ClientConfig::default()
|
|
};
|
|
config.socket_config.ipv4_only = true;
|
|
|
|
tokio_runtime().block_on(async {
|
|
let before = resolution_call_counts();
|
|
let remote = resolve_remote_tokio(&config).await.unwrap();
|
|
let after = resolution_call_counts();
|
|
|
|
assert!(remote.is_ipv4());
|
|
assert_eq!(after.0, before.0);
|
|
assert_eq!(after.1, before.1 + 1);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_resolver_selects_ipv6_for_ipv6_only_hostname() {
|
|
let mut config = ClientConfig {
|
|
server_addr: "localhost:2112".to_owned(),
|
|
..ClientConfig::default()
|
|
};
|
|
config.socket_config.ipv6_only = true;
|
|
|
|
tokio_runtime().block_on(async {
|
|
let remote = resolve_remote_tokio(&config).await.unwrap();
|
|
assert!(remote.is_ipv6());
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_resolver_literal_path_bypasses_all_name_resolution() {
|
|
let config = ClientConfig {
|
|
server_addr: "127.0.0.1:2112".to_owned(),
|
|
..ClientConfig::default()
|
|
};
|
|
|
|
tokio_runtime().block_on(async {
|
|
let before = resolution_call_counts();
|
|
let remote = resolve_remote_tokio(&config).await.unwrap();
|
|
let after = resolution_call_counts();
|
|
|
|
assert_eq!(remote, SocketAddr::from(([127, 0, 0, 1], 2112)));
|
|
assert_eq!(after, before);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_resolver_rejects_disallowed_literal_family() {
|
|
let mut config = ClientConfig {
|
|
server_addr: "127.0.0.1:2112".to_owned(),
|
|
..ClientConfig::default()
|
|
};
|
|
config.socket_config.ipv6_only = true;
|
|
|
|
tokio_runtime().block_on(async {
|
|
assert!(matches!(
|
|
resolve_remote_tokio(&config).await,
|
|
Err(ClientError::Resolve { .. })
|
|
));
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
#[test]
|
|
fn tokio_resolver_rejects_mixed_family_restrictions() {
|
|
let mut config = ClientConfig {
|
|
server_addr: "127.0.0.1:2112".to_owned(),
|
|
..ClientConfig::default()
|
|
};
|
|
config.socket_config.ipv4_only = true;
|
|
config.socket_config.ipv6_only = true;
|
|
|
|
tokio_runtime().block_on(async {
|
|
assert!(matches!(
|
|
resolve_remote_tokio(&config).await,
|
|
Err(ClientError::Resolve { .. })
|
|
));
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
fn tokio_runtime() -> tokio::runtime::Runtime {
|
|
tokio::runtime::Builder::new_current_thread()
|
|
.enable_io()
|
|
.build()
|
|
.unwrap()
|
|
}
|
|
|
|
#[cfg(feature = "tokio")]
|
|
fn ipv6_loopback_unavailable(error: &std::io::Error) -> bool {
|
|
matches!(
|
|
error.kind(),
|
|
std::io::ErrorKind::AddrNotAvailable | std::io::ErrorKind::Unsupported
|
|
)
|
|
}
|
|
}
|