use std::io;
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering};
use tokio::net::TcpStream;
use super::connect_from;
#[derive(Clone, Debug)]
pub struct OutboundNetworkPolicy {
sources: Arc<[SourceState]>,
}
#[derive(Debug)]
struct SourceState {
address: IpAddr,
in_flight: AtomicUsize,
failures: AtomicU32,
}
struct InFlightConnectionGuard<'a>(&'a AtomicUsize);
impl InFlightConnectionGuard<'_> {
fn new(in_flight: &AtomicUsize) -> InFlightConnectionGuard<'_> {
in_flight.fetch_add(1, Ordering::Relaxed);
InFlightConnectionGuard(in_flight)
}
}
impl Drop for InFlightConnectionGuard<'_> {
fn drop(&mut self) {
self.0.fetch_sub(1, Ordering::Relaxed);
}
}
impl SourceState {
fn new(address: IpAddr) -> Self {
Self {
address,
in_flight: AtomicUsize::new(0),
failures: AtomicU32::new(0),
}
}
fn score(&self) -> usize {
self.in_flight
.load(Ordering::Relaxed)
.saturating_mul(16)
.saturating_add(self.failures.load(Ordering::Relaxed) as usize)
}
}
impl OutboundNetworkPolicy {
pub fn direct() -> Self {
Self {
sources: Arc::new([]),
}
}
pub fn new(addresses: Vec<IpAddr>) -> Result<Self, String> {
let mut unique = Vec::with_capacity(addresses.len());
for address in addresses {
if !unique.contains(&address) {
unique.push(address);
}
}
if unique.is_empty() {
return Err("at least one outbound source address is required".to_string());
}
Ok(Self {
sources: unique
.into_iter()
.map(SourceState::new)
.collect::<Vec<_>>()
.into(),
})
}
pub fn single(address: IpAddr) -> Self {
Self::new(vec![address]).expect("a single source address is never empty")
}
pub fn is_direct(&self) -> bool {
self.sources.is_empty()
}
pub fn addresses(&self) -> Vec<IpAddr> {
self.sources.iter().map(|source| source.address).collect()
}
pub async fn resolve_spec(spec: &str) -> Result<Self, String> {
let mut addresses = Vec::new();
for value in spec
.split(',')
.map(str::trim)
.filter(|value| !value.is_empty())
{
if let Ok(address) = value.parse::<IpAddr>() {
if !addresses.contains(&address) {
addresses.push(address);
}
continue;
}
let interface_addresses = interface_addresses(value);
if !interface_addresses.is_empty() {
for address in interface_addresses {
if !addresses.contains(&address) {
addresses.push(address);
}
}
continue;
}
let resolved = tokio::net::lookup_host((value, 0))
.await
.map_err(|error| format!("cannot resolve '{value}': {error}"))?;
for address in resolved.map(|address| address.ip()) {
if !addresses.contains(&address) {
addresses.push(address);
}
}
}
Self::new(addresses)
}
pub fn source_for(&self, remote: SocketAddr) -> io::Result<Option<IpAddr>> {
let Some(source) = self.best_source(remote) else {
if self.is_direct() {
return Ok(None);
}
return Err(family_mismatch(remote));
};
Ok(Some(source.address))
}
pub async fn source_for_host(&self, host: &str, port: u16) -> io::Result<Option<IpAddr>> {
if self.is_direct() {
return Ok(None);
}
let addresses = tokio::net::lookup_host((host, port)).await?;
for remote in addresses {
if let Ok(source) = self.source_for(remote) {
return Ok(source);
}
}
Err(family_mismatch(SocketAddr::new(
IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED),
port,
)))
}
pub async fn resolve_udp_host(&self, host: &str, port: u16) -> io::Result<SocketAddr> {
let host = host
.strip_prefix('[')
.and_then(|host| host.strip_suffix(']'))
.unwrap_or(host);
if let Ok(address) = host.parse::<IpAddr>() {
let remote = SocketAddr::new(address, port);
if self.is_direct() || self.best_source(remote).is_some() {
return Ok(remote);
}
return Err(family_mismatch(remote));
}
let addresses = tokio::net::lookup_host((host, port)).await?;
for remote in addresses {
if self.is_direct() || self.best_source(remote).is_some() {
return Ok(remote);
}
}
Err(family_mismatch(SocketAddr::new(
IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED),
port,
)))
}
pub async fn connect_host(&self, host: &str, port: u16) -> io::Result<TcpStream> {
let addresses = tokio::net::lookup_host((host, port)).await?;
let mut last_error = None;
for remote in addresses {
if !self.is_direct() && self.best_source(remote).is_none() {
continue;
}
match self.connect(remote).await {
Ok(stream) => return Ok(stream),
Err(error) => last_error = Some(error),
}
}
Err(last_error.unwrap_or_else(|| {
io::Error::new(io::ErrorKind::AddrNotAvailable, "no compatible address")
}))
}
pub async fn connect(&self, remote: SocketAddr) -> io::Result<TcpStream> {
let Some(source) = self.best_source(remote) else {
if self.is_direct() {
return TcpStream::connect(remote).await;
}
return Err(family_mismatch(remote));
};
let in_flight_guard = InFlightConnectionGuard::new(&source.in_flight);
let result = connect_from(source.address, remote).await;
drop(in_flight_guard);
let failed = result.is_err();
let mut failures = source.failures.load(Ordering::Relaxed);
loop {
let updated = if failed {
failures.saturating_add(1)
} else {
failures.saturating_sub(1)
};
match source.failures.compare_exchange_weak(
failures,
updated,
Ordering::Relaxed,
Ordering::Relaxed,
) {
Ok(_) => break,
Err(observed) => failures = observed,
}
}
result
}
pub async fn bind_udp(&self, port: u16) -> io::Result<tokio::net::UdpSocket> {
let local = self
.sources
.first()
.map(|source| SocketAddr::new(source.address, port))
.unwrap_or_else(|| SocketAddr::new(IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED), port));
tokio::net::UdpSocket::bind(local).await
}
pub async fn bind_udp_for_family(
&self,
port: u16,
ipv6: bool,
) -> io::Result<tokio::net::UdpSocket> {
let local = if self.is_direct() {
SocketAddr::new(
if ipv6 {
IpAddr::V6(std::net::Ipv6Addr::UNSPECIFIED)
} else {
IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED)
},
port,
)
} else {
let source = self
.sources
.iter()
.filter(|source| source.address.is_ipv6() == ipv6)
.min_by_key(|source| source.score())
.ok_or_else(|| {
family_mismatch(SocketAddr::new(
if ipv6 {
IpAddr::V6(std::net::Ipv6Addr::UNSPECIFIED)
} else {
IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED)
},
port,
))
})?;
SocketAddr::new(source.address, port)
};
tokio::net::UdpSocket::bind(local).await
}
fn best_source(&self, remote: SocketAddr) -> Option<&SourceState> {
self.sources
.iter()
.filter(|source| source.address.is_ipv4() == remote.is_ipv4())
.min_by_key(|source| source.score())
}
}
#[cfg(unix)]
fn interface_addresses(name: &str) -> Vec<IpAddr> {
use std::ffi::CStr;
use std::ptr;
let mut result = Vec::new();
unsafe {
let mut head = ptr::null_mut();
if libc::getifaddrs(&mut head) != 0 {
return result;
}
let mut current = head;
while !current.is_null() {
let interface = &*current;
let matches = !interface.ifa_name.is_null()
&& CStr::from_ptr(interface.ifa_name).to_bytes() == name.as_bytes();
if matches && !interface.ifa_addr.is_null() {
match (*interface.ifa_addr).sa_family as i32 {
libc::AF_INET => {
let address = *(interface.ifa_addr as *const libc::sockaddr_in);
result.push(IpAddr::V4(std::net::Ipv4Addr::from(
u32::from_be(address.sin_addr.s_addr).to_be_bytes(),
)));
}
libc::AF_INET6 => {
let address = *(interface.ifa_addr as *const libc::sockaddr_in6);
result.push(IpAddr::V6(std::net::Ipv6Addr::from(
address.sin6_addr.s6_addr,
)));
}
_ => {}
}
}
current = interface.ifa_next;
}
libc::freeifaddrs(head);
}
result
}
#[cfg(windows)]
fn interface_addresses(name: &str) -> Vec<IpAddr> {
use std::ffi::CStr;
use windows_sys::Win32::NetworkManagement::IpHelper::{
GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH,
};
use windows_sys::Win32::Networking::WinSock::{
AF_INET, AF_INET6, AF_UNSPEC, SOCKADDR_IN, SOCKADDR_IN6,
};
let mut size = 15_000u32;
let mut buffer = vec![0u8; size as usize];
let status = unsafe {
GetAdaptersAddresses(
AF_UNSPEC as u32,
0,
std::ptr::null(),
buffer.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH,
&mut size,
)
};
if status != 0 {
return Vec::new();
}
let mut result = Vec::new();
let mut adapter = buffer.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH;
while !adapter.is_null() {
let current = unsafe { &*adapter };
let adapter_name = if current.AdapterName.is_null() {
"".to_string()
} else {
unsafe { CStr::from_ptr(current.AdapterName as *const i8) }
.to_string_lossy()
.into_owned()
};
let friendly_name = if current.FriendlyName.is_null() {
String::new()
} else {
let mut length = 0;
unsafe {
while *current.FriendlyName.add(length) != 0 {
length += 1;
}
String::from_utf16_lossy(std::slice::from_raw_parts(current.FriendlyName, length))
}
};
if adapter_name == name || friendly_name == name {
let mut address = current.FirstUnicastAddress;
while !address.is_null() {
let socket_address = unsafe { (*address).Address.lpSockaddr };
if !socket_address.is_null() {
let family = unsafe { (*socket_address).sa_family };
unsafe {
if family == AF_INET {
let value = *(socket_address as *const SOCKADDR_IN);
result.push(IpAddr::V4(std::net::Ipv4Addr::from(
value.sin_addr.S_un.S_addr.to_ne_bytes(),
)));
} else if family == AF_INET6 {
let value = *(socket_address as *const SOCKADDR_IN6);
result
.push(IpAddr::V6(std::net::Ipv6Addr::from(value.sin6_addr.u.Byte)));
}
}
}
address = unsafe { (*address).Next };
}
break;
}
adapter = current.Next;
}
result
}
fn family_mismatch(remote: SocketAddr) -> io::Error {
io::Error::new(
io::ErrorKind::AddrNotAvailable,
format!("no configured outbound source matches {remote}"),
)
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn direct_policy_does_not_require_hostname_resolution_for_source_selection() {
let policy = OutboundNetworkPolicy::direct();
assert_eq!(policy.source_for_host("\0", 80).await.unwrap(), None);
}
#[tokio::test]
async fn policy_connect_uses_configured_source_address() {
let listener = tokio::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
.await
.unwrap();
let remote = listener.local_addr().unwrap();
let policy = OutboundNetworkPolicy::single(IpAddr::V4(std::net::Ipv4Addr::LOCALHOST));
let client = policy.connect(remote).await.unwrap();
let (_, peer) = listener.accept().await.unwrap();
assert_eq!(client.local_addr().unwrap().ip(), peer.ip());
assert_eq!(peer.ip(), IpAddr::V4(std::net::Ipv4Addr::LOCALHOST));
}
#[tokio::test]
async fn policy_rejects_a_family_without_a_matching_source() {
let policy = OutboundNetworkPolicy::single(IpAddr::V4(std::net::Ipv4Addr::LOCALHOST));
let error = policy
.connect(SocketAddr::new(std::net::Ipv6Addr::LOCALHOST.into(), 1))
.await
.unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::AddrNotAvailable);
}
#[tokio::test]
async fn udp_host_resolution_accepts_bracketed_ipv6_literals_with_matching_source() {
let policy = OutboundNetworkPolicy::new(vec![
IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 2)),
IpAddr::V6(std::net::Ipv6Addr::LOCALHOST),
])
.unwrap();
assert_eq!(
policy.resolve_udp_host("[::1]", 6881).await.unwrap(),
SocketAddr::new(IpAddr::V6(std::net::Ipv6Addr::LOCALHOST), 6881)
);
}
#[test]
fn source_selection_prefers_the_less_loaded_source() {
let policy = OutboundNetworkPolicy::new(vec![
IpAddr::V4(std::net::Ipv4Addr::LOCALHOST),
IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 2)),
])
.unwrap();
policy.sources[0].in_flight.store(3, Ordering::Relaxed);
assert_eq!(
policy.source_for("127.0.0.1:1".parse().unwrap()).unwrap(),
Some(IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 2)))
);
}
#[test]
fn cancelled_connection_releases_its_in_flight_source_slot() {
let policy = OutboundNetworkPolicy::single(IpAddr::V4(std::net::Ipv4Addr::LOCALHOST));
{
let _guard = InFlightConnectionGuard::new(&policy.sources[0].in_flight);
assert_eq!(policy.sources[0].in_flight.load(Ordering::Relaxed), 1);
}
assert_eq!(policy.sources[0].in_flight.load(Ordering::Relaxed), 0);
}
}