use std::io;
use std::net::SocketAddr;
use tokio::net::UdpSocket;
use tracing::{debug, info, warn};
#[allow(unused_imports)]
use super::constants;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AddressFamily {
Ipv4,
Ipv6,
}
impl AddressFamily {
fn wildcard_addr(self) -> &'static str {
match self {
Self::Ipv4 => "0.0.0.0",
Self::Ipv6 => "::",
}
}
fn from_addr(addr: &str) -> Self {
if addr.contains(':') {
Self::Ipv6
} else {
Self::Ipv4
}
}
}
pub struct DhtTransport {
socket: UdpSocket,
family: AddressFamily,
bind_addr: SocketAddr,
}
impl DhtTransport {
pub async fn bind(addr: &str, port: u16) -> io::Result<Self> {
let family = AddressFamily::from_addr(addr);
let ip_str = if addr.is_empty() {
family.wildcard_addr()
} else {
addr
};
let socket = UdpSocket::bind(format!("{}:{}", ip_str, port)).await?;
let bind_addr = socket.local_addr()?;
info!(addr = %bind_addr, family = ?family, "DHT transport bound");
Ok(Self {
socket,
family,
bind_addr,
})
}
pub async fn bind_with_port_range(addr: &str, start: u16, end: u16) -> io::Result<Self> {
let family = AddressFamily::from_addr(addr);
let ip_str = if addr.is_empty() {
family.wildcard_addr()
} else {
addr
};
for port in start..=end {
match UdpSocket::bind(format!("{}:{}", ip_str, port)).await {
Ok(socket) => {
let bind_addr = socket.local_addr()?;
info!(addr = %bind_addr, family = ?family, "DHT transport bound (port range)");
return Ok(Self {
socket,
family,
bind_addr,
});
}
Err(e) if e.kind() == io::ErrorKind::AddrInUse => {
debug!(port, "DHT port in use, trying next");
continue;
}
Err(e) => return Err(e),
}
}
warn!(start, end, "All DHT ports in range exhausted");
Err(io::Error::new(
io::ErrorKind::AddrInUse,
format!("no available port in range {}-{}", start, end),
))
}
pub async fn send_message(&self, data: &[u8], addr: SocketAddr) -> io::Result<usize> {
let n = self.socket.send_to(data, addr).await?;
debug!(target = %addr, len = n, "DHT message sent");
Ok(n)
}
pub async fn recv_message(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
let (n, from) = self.socket.recv_from(buf).await?;
debug!(from = %from, len = n, "DHT message received");
Ok((n, from))
}
pub fn local_addr(&self) -> io::Result<SocketAddr> {
Ok(self.bind_addr)
}
pub fn address_family(&self) -> AddressFamily {
self.family
}
pub fn bound_port(&self) -> u16 {
self.bind_addr.port()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{IpAddr, Ipv4Addr};
#[tokio::test]
async fn bind_auto_assign_port() {
let t = DhtTransport::bind("", 0).await.unwrap();
assert!(t.bound_port() > 0);
assert_eq!(t.address_family(), AddressFamily::Ipv4);
assert!(t.local_addr().unwrap().is_ipv4());
}
#[tokio::test]
async fn bind_ipv6_auto_assign() {
let t = DhtTransport::bind("::", 0).await.unwrap();
assert!(t.bound_port() > 0);
assert_eq!(t.address_family(), AddressFamily::Ipv6);
}
#[tokio::test]
async fn send_recv_roundtrip() {
let sender = DhtTransport::bind("", 0).await.unwrap();
let receiver = DhtTransport::bind("", 0).await.unwrap();
let target = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), receiver.bound_port());
let payload = b"d1:eli201e1:t2:aa1:y1:ee";
let sent = sender.send_message(payload, target).await.unwrap();
assert_eq!(sent, payload.len());
let mut buf = [0u8; constants::DHT_MAX_MESSAGE_SIZE];
let (n, from) = receiver.recv_message(&mut buf).await.unwrap();
assert_eq!(n, payload.len());
assert_eq!(&buf[..n], payload);
assert_eq!(from.port(), sender.local_addr().unwrap().port());
}
#[tokio::test]
async fn address_family_detection() {
let v4 = DhtTransport::bind("0.0.0.0", 0).await.unwrap();
assert_eq!(v4.address_family(), AddressFamily::Ipv4);
let v6 = DhtTransport::bind("::", 0).await.unwrap();
assert_eq!(v6.address_family(), AddressFamily::Ipv6);
}
#[tokio::test]
async fn port_range_binds_first_available() {
let t = DhtTransport::bind_with_port_range("", 59600, 59610)
.await
.expect("should bind within range");
assert!((59600..=59610).contains(&t.bound_port()));
}
#[tokio::test]
async fn port_range_exhausted() {
let mut held = Vec::new();
for p in 59700u16..=59702 {
if let Ok(t) = DhtTransport::bind("", p).await {
held.push(t);
}
}
let result = DhtTransport::bind_with_port_range("", 59700, 59702).await;
if let Ok(t) = result {
assert!((59700..=59702).contains(&t.bound_port()));
}
drop(held);
}
}