use std::collections::HashMap;
use std::net::{SocketAddr, UdpSocket};
use std::sync::{Arc, OnceLock};
use std::time::{Duration, Instant};
use crate::bittorrent::utp::connection::{ConnectionError, ConnectionState, UtpConnection};
use crate::bittorrent::utp::packet::{PacketType, UtpPacket, UtpPacketError};
use crate::bittorrent::utp::timer::{TimerManager, TimerType};
mod close;
#[cfg(test)]
mod tests;
mod timers;
const MAX_CONNECTIONS: usize = 100;
const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
const DEFAULT_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
const DEFAULT_KEEPALIVE_INTERVAL: Duration = Duration::from_secs(15);
const MAX_UDP_RECV_BUFFER: usize = 65535;
#[derive(Debug, thiserror::Error)]
pub enum UtpSocketError {
#[error("Failed to bind UDP socket: {0}")]
BindFailed(std::io::Error),
#[error("Failed to send packet: {0}")]
SendFailed(std::io::Error),
#[error("Failed to receive packet: {0}")]
RecvFailed(std::io::Error),
#[error("Connection error: {0}")]
ConnectionError(#[from] ConnectionError),
#[error("Packet error: {0}")]
PacketError(#[from] UtpPacketError),
#[error("Maximum connections reached")]
MaxConnectionsReached,
#[error("Connection not found: {0}")]
ConnectionNotFound(u16),
#[error("Address not found for connection: {0}")]
AddressNotFound(u16),
#[error("Socket closed")]
SocketClosed,
#[error("Invalid packet from {addr}: {reason}")]
InvalidPacket { addr: SocketAddr, reason: String },
#[error("Timeout: {0}")]
Timeout(String),
}
pub struct UtpSocket {
socket: UdpSocket,
async_socket: OnceLock<Arc<tokio::net::UdpSocket>>,
connections: HashMap<u16, UtpConnection>,
timers: TimerManager,
local_addr: SocketAddr,
timestamp_origin: Instant,
connect_timeout: Duration,
idle_timeout: Duration,
keepalive_interval: Duration,
is_closed: bool,
recv_buffer: Vec<u8>,
}
impl UtpSocket {
pub fn bind(addr: &str) -> Result<Self, UtpSocketError> {
let address = addr.parse::<SocketAddr>().map_err(|error| {
UtpSocketError::BindFailed(std::io::Error::new(std::io::ErrorKind::InvalidInput, error))
})?;
Self::bind_addr(address)
}
pub fn bind_addr(addr: SocketAddr) -> Result<Self, UtpSocketError> {
let socket = UdpSocket::bind(addr).map_err(UtpSocketError::BindFailed)?;
let local_addr = socket.local_addr().map_err(UtpSocketError::BindFailed)?;
socket
.set_nonblocking(true)
.map_err(UtpSocketError::BindFailed)?;
Ok(Self {
socket,
async_socket: OnceLock::new(),
connections: HashMap::new(),
timers: TimerManager::new(),
local_addr,
timestamp_origin: Instant::now(),
connect_timeout: DEFAULT_CONNECT_TIMEOUT,
idle_timeout: DEFAULT_IDLE_TIMEOUT,
keepalive_interval: DEFAULT_KEEPALIVE_INTERVAL,
is_closed: false,
recv_buffer: vec![0u8; MAX_UDP_RECV_BUFFER],
})
}
pub fn bind_any() -> Result<Self, UtpSocketError> {
Self::bind("0.0.0.0:0")
}
pub fn bind_port(port: u16) -> Result<Self, UtpSocketError> {
Self::bind(&format!("0.0.0.0:{}", port))
}
pub fn local_addr(&self) -> SocketAddr {
self.local_addr
}
pub fn readiness_socket(&self) -> Result<Arc<tokio::net::UdpSocket>, UtpSocketError> {
if let Some(socket) = self.async_socket.get() {
return Ok(Arc::clone(socket));
}
let socket = self
.socket
.try_clone()
.map_err(UtpSocketError::RecvFailed)?;
let async_socket =
Arc::new(tokio::net::UdpSocket::from_std(socket).map_err(UtpSocketError::RecvFailed)?);
let _ = self.async_socket.set(Arc::clone(&async_socket));
Ok(self.async_socket.get().cloned().unwrap_or(async_socket))
}
pub fn next_timer_delay(&self) -> Option<Duration> {
self.timers.next_timer().map(|(_, _, remaining)| remaining)
}
pub fn set_connect_timeout(&mut self, timeout: Duration) {
self.connect_timeout = timeout;
}
pub fn set_idle_timeout(&mut self, timeout: Duration) {
self.idle_timeout = timeout;
}
pub fn set_keepalive_interval(&mut self, interval: Duration) {
self.keepalive_interval = interval;
}
pub fn is_closed(&self) -> bool {
self.is_closed
}
pub fn connection_count(&self) -> usize {
self.connections.len()
}
pub fn connect(&mut self, remote_addr: SocketAddr) -> Result<u16, UtpSocketError> {
if self.is_closed {
return Err(UtpSocketError::SocketClosed);
}
if self.connections.len() >= MAX_CONNECTIONS {
return Err(UtpSocketError::MaxConnectionsReached);
}
let mut attempts = 0;
let (conn, syn_packet, conn_id) = loop {
attempts += 1;
if attempts > MAX_CONNECTIONS + 1 {
return Err(UtpSocketError::MaxConnectionsReached);
}
let mut conn = UtpConnection::new();
let syn_packet = conn.connect(remote_addr)?;
let conn_id = conn.local_connection_id();
if !self.connections.contains_key(&conn_id) {
break (conn, syn_packet, conn_id);
}
};
self.send_packet(&syn_packet, remote_addr)?;
let rto = conn.rto();
self.connections.insert(conn_id, conn);
self.timers
.set_timer(conn_id, TimerType::ConnectTimeout, self.connect_timeout);
self.timers
.set_timer(conn_id, TimerType::Retransmit(syn_packet.seq_nr), rto);
Ok(conn_id)
}
fn send_packet(&self, packet: &UtpPacket, addr: SocketAddr) -> Result<(), UtpSocketError> {
let data = packet.to_bytes();
self.socket
.send_to(&data, addr)
.map_err(UtpSocketError::SendFailed)?;
Ok(())
}
pub fn send(&mut self, conn_id: u16, data: &[u8]) -> Result<usize, UtpSocketError> {
if self.is_closed {
return Err(UtpSocketError::SocketClosed);
}
let (remote_addr, rto) = {
let conn = self
.connections
.get(&conn_id)
.ok_or(UtpSocketError::ConnectionNotFound(conn_id))?;
if !conn.is_established() {
return Err(UtpSocketError::ConnectionError(
ConnectionError::NotConnected,
));
}
let remote_addr = conn
.remote_addr()
.ok_or(UtpSocketError::AddressNotFound(conn_id))?;
(remote_addr, conn.rto())
};
let packets = {
let conn = self
.connections
.get_mut(&conn_id)
.ok_or(UtpSocketError::ConnectionNotFound(conn_id))?;
conn.send_data(data)?
};
let mut bytes_sent = 0;
for packet in &packets {
bytes_sent += packet.payload.len();
self.send_packet(packet, remote_addr)?;
if let Some(conn) = self.connections.get_mut(&conn_id) {
conn.record_packet_sent(packet.seq_nr);
}
self.timers
.set_timer(conn_id, TimerType::Retransmit(packet.seq_nr), rto);
}
Ok(bytes_sent)
}
pub fn recv(&mut self, conn_id: u16, buf: &mut [u8]) -> Result<usize, UtpSocketError> {
if self.is_closed {
return Err(UtpSocketError::SocketClosed);
}
self.process_incoming_packets()?;
let conn = self
.connections
.get_mut(&conn_id)
.ok_or(UtpSocketError::ConnectionNotFound(conn_id))?;
Ok(conn.recv_into(buf))
}
fn process_incoming_packets(&mut self) -> Result<(), UtpSocketError> {
let received = if let Some(socket) = self.async_socket.get() {
socket.try_recv_from(&mut self.recv_buffer)
} else {
self.socket.recv_from(&mut self.recv_buffer)
};
match received {
Ok((len, addr)) => {
let packet = UtpPacket::from_bytes(&self.recv_buffer[..len])?;
self.handle_packet(&packet, addr)?;
}
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {}
Err(e) => return Err(UtpSocketError::RecvFailed(e)),
}
Ok(())
}
fn handle_packet(
&mut self,
packet: &UtpPacket,
addr: SocketAddr,
) -> Result<(), UtpSocketError> {
let packet_type = packet.packet_type()?;
match packet_type {
PacketType::StSyn => self.handle_syn(packet, addr)?,
PacketType::StData | PacketType::StAck | PacketType::StFin => {
let conn_id = self.find_connection_for_packet(packet, addr)?;
if let Some(conn_id) = conn_id {
let (
response_packets,
acknowledged,
fast_retransmissions,
retransmission_timeout,
state,
keepalive_interval,
) = {
let conn = self.connections.get_mut(&conn_id);
if let Some(conn) = conn {
let handling = conn.on_packet_received_with_acknowledgements(packet)?;
let mut congestion_loss_applied = false;
let mut fast_retransmissions = Vec::new();
for seq_nr in handling.fast_retransmit {
if let Some(retransmission) =
conn.retransmit_packet(seq_nr, !congestion_loss_applied)
{
if retransmission.packet_type().ok() == Some(PacketType::StData)
{
congestion_loss_applied = true;
}
conn.record_packet_sent(seq_nr);
fast_retransmissions.push((seq_nr, retransmission));
}
}
let keepalive_interval = self.keepalive_interval;
(
handling.response_packets,
handling.acknowledged,
fast_retransmissions,
conn.rto(),
conn.state(),
keepalive_interval,
)
} else {
return Ok(());
}
};
for resp_packet in response_packets {
self.send_packet(&resp_packet, addr)?;
}
self.timers.cancel_timer(conn_id, TimerType::ConnectTimeout);
for seq_nr in acknowledged {
self.timers
.cancel_timer(conn_id, TimerType::Retransmit(seq_nr));
}
for (seq_nr, retransmission) in fast_retransmissions {
self.timers
.cancel_timer(conn_id, TimerType::Retransmit(seq_nr));
self.send_packet(&retransmission, addr)?;
self.timers.set_timer(
conn_id,
TimerType::Retransmit(seq_nr),
retransmission_timeout,
);
}
match state {
ConnectionState::Closed => {
self.close_connection_internal(conn_id)?;
}
ConnectionState::Established => {
self.timers.set_timer(
conn_id,
TimerType::Keepalive,
keepalive_interval,
);
}
ConnectionState::Closing => {
self.timers.set_timer(
conn_id,
TimerType::IdleTimeout,
self.idle_timeout,
);
}
_ => {}
}
}
}
PacketType::StReset => {
let conn_id = self.find_connection_for_packet(packet, addr)?;
if let Some(conn_id) = conn_id {
self.close_connection_internal(conn_id)?;
}
}
}
Ok(())
}
fn handle_syn(&mut self, packet: &UtpPacket, addr: SocketAddr) -> Result<(), UtpSocketError> {
let receive_id = packet.connection_id.wrapping_add(1);
if let Some(conn) = self.connections.get_mut(&receive_id) {
if conn.remote_addr() == Some(addr)
&& let Some(response) = conn.syn_response(packet)
{
self.send_packet(&response, addr)?;
}
return Ok(());
}
if self.connections.len() >= MAX_CONNECTIONS {
let mut reset = UtpPacket::reset(packet.connection_id);
reset.timestamp_microseconds = self.timestamp_origin.elapsed().as_micros() as u32;
self.send_packet(&reset, addr)?;
return Err(UtpSocketError::MaxConnectionsReached);
}
let mut conn = UtpConnection::new();
let syn_ack = conn.accept(packet, addr)?;
let conn_id = conn.local_connection_id();
self.send_packet(&syn_ack, addr)?;
self.connections.insert(conn_id, conn);
self.timers
.set_timer(conn_id, TimerType::Keepalive, self.keepalive_interval);
Ok(())
}
fn find_connection_for_packet(
&self,
packet: &UtpPacket,
addr: SocketAddr,
) -> Result<Option<u16>, UtpSocketError> {
Ok(self
.connections
.get(&packet.connection_id)
.filter(|conn| conn.remote_addr() == Some(addr))
.map(|_| packet.connection_id))
}
pub fn connection_state(&self, conn_id: u16) -> Result<ConnectionState, UtpSocketError> {
let conn = self
.connections
.get(&conn_id)
.ok_or(UtpSocketError::ConnectionNotFound(conn_id))?;
Ok(conn.state())
}
pub fn connection_stats(&self, conn_id: u16) -> Result<ConnectionStats, UtpSocketError> {
let conn = self
.connections
.get(&conn_id)
.ok_or(UtpSocketError::ConnectionNotFound(conn_id))?;
Ok(ConnectionStats {
state: conn.state(),
local_connection_id: conn.local_connection_id(),
remote_connection_id: conn.remote_connection_id(),
remote_addr: conn.remote_addr(),
rtt: conn.rtt(),
rto: conn.rto(),
congestion_window: conn.congestion_window(),
receive_window: conn.receive_window(),
bytes_in_flight: conn.bytes_in_flight(),
idle_time: conn.idle_time(),
})
}
pub fn poll_recv(&mut self) -> Result<Vec<(u16, Vec<u8>)>, UtpSocketError> {
self.process_incoming_packets()?;
let mut results = Vec::new();
let conn_ids: Vec<u16> = self.connections.keys().copied().collect();
for conn_id in conn_ids {
if let Some(conn) = self.connections.get_mut(&conn_id) {
let data = conn.recv_data();
if !data.is_empty() {
results.push((conn_id, data));
}
}
}
Ok(results)
}
pub fn connection_ids(&self) -> Vec<u16> {
self.connections.keys().copied().collect()
}
}
impl Drop for UtpSocket {
fn drop(&mut self) {
self.close();
}
}
#[derive(Debug, Clone)]
pub struct ConnectionStats {
pub state: ConnectionState,
pub local_connection_id: u16,
pub remote_connection_id: u16,
pub remote_addr: Option<SocketAddr>,
pub rtt: Duration,
pub rto: Duration,
pub congestion_window: u32,
pub receive_window: u32,
pub bytes_in_flight: u32,
pub idle_time: Duration,
}