use std::collections::{HashMap, HashSet};
use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket};
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use std::time::Duration;
use tokio::sync::RwLock;
use tokio_util::sync::CancellationToken;
use tracing::{debug, info, trace, warn};
use crate::constants;
use crate::engine::lpd_manager::{LpdPeer, parse_lpd_announcement};
const MAX_MESSAGES_PER_ITERATION: usize = 20;
const LPD_BUFFER_SIZE: usize = constants::LPD_RECEIVE_BUFFER_SIZE;
pub struct LpdReceiveLoop {
task_handle: Option<tokio::task::JoinHandle<()>>,
cancel_token: CancellationToken,
is_running: Arc<AtomicBool>,
}
impl LpdReceiveLoop {
pub fn new() -> Self {
Self {
task_handle: None,
cancel_token: CancellationToken::new(),
is_running: Arc::new(AtomicBool::new(false)),
}
}
pub async fn start(
&mut self,
peers: Arc<RwLock<HashMap<String, HashSet<LpdPeer>>>>,
active_hashes: Arc<RwLock<HashSet<String>>>,
) -> Result<(), String> {
if self.is_running.load(Ordering::Acquire) {
debug!("LPD receive loop already running");
return Ok(());
}
let socket = create_lpd_socket()?;
let async_socket = tokio::net::UdpSocket::from_std(socket)
.map_err(|e| format!("Failed to convert LPD socket to async: {}", e))?;
let cancel_token = self.cancel_token.clone();
let is_running = Arc::clone(&self.is_running);
info!(
addr = %constants::LPD_MULTICAST_ADDRESS,
port = constants::LPD_PORT,
"LPD receive loop starting"
);
is_running.store(true, Ordering::Release);
let handle = tokio::spawn(async move {
run_receive_loop(async_socket, peers, active_hashes, cancel_token).await;
is_running.store(false, Ordering::Release);
});
self.task_handle = Some(handle);
Ok(())
}
pub async fn stop(&mut self) {
if !self.is_running.load(Ordering::Acquire) {
return;
}
self.cancel_token.cancel();
if let Some(handle) = self.task_handle.take() {
match tokio::time::timeout(Duration::from_secs(5), handle).await {
Ok(Ok(())) => {
info!("LPD receive loop stopped gracefully");
}
Ok(Err(e)) => {
warn!(error = %e, "LPD receive loop task panicked");
}
Err(_) => {
warn!("LPD receive loop stop timed out after 5s");
}
}
}
self.is_running.store(false, Ordering::Release);
self.cancel_token = CancellationToken::new();
}
pub fn is_running(&self) -> bool {
self.is_running.load(Ordering::Acquire)
}
pub fn cancellation_token(&self) -> CancellationToken {
self.cancel_token.clone()
}
}
impl Default for LpdReceiveLoop {
fn default() -> Self {
Self::new()
}
}
fn create_lpd_socket() -> Result<UdpSocket, String> {
let multicast_ip: Ipv4Addr = constants::LPD_MULTICAST_ADDRESS
.parse()
.map_err(|e| format!("Invalid LPD multicast IP: {}", e))?;
let port = constants::LPD_PORT;
#[cfg(unix)]
{
use std::os::unix::io::FromRawFd;
let fd = unsafe { libc::socket(libc::AF_INET, libc::SOCK_DGRAM, 0) };
if fd < 0 {
return Err(format!(
"Failed to create LPD UDP socket: {}",
std::io::Error::last_os_error()
));
}
let optval: i32 = 1;
let result = unsafe {
libc::setsockopt(
fd,
libc::SOL_SOCKET,
libc::SO_REUSEADDR,
&optval as *const i32 as *const libc::c_void,
std::mem::size_of::<i32>() as libc::socklen_t,
)
};
if result != 0 {
warn!(
"Failed to set SO_REUSEADDR on LPD socket (non-fatal): {}",
std::io::Error::last_os_error()
);
}
let bind_addr = SocketAddrV4::new(multicast_ip, port);
#[cfg(target_os = "macos")]
let raw_bind_addr = libc::sockaddr_in {
sin_len: std::mem::size_of::<libc::sockaddr_in>() as u8,
sin_family: libc::AF_INET as _,
sin_port: port.to_be(),
sin_addr: libc::in_addr {
s_addr: u32::from_be_bytes(multicast_ip.octets()),
},
sin_zero: [0; 8],
};
#[cfg(not(target_os = "macos"))]
let raw_bind_addr = libc::sockaddr_in {
sin_family: libc::AF_INET as _,
sin_port: port.to_be(),
sin_addr: libc::in_addr {
s_addr: u32::from_be_bytes(multicast_ip.octets()),
},
sin_zero: [0; 8],
};
let bind_result = unsafe {
libc::bind(
fd,
(&raw_bind_addr as *const libc::sockaddr_in).cast(),
std::mem::size_of::<libc::sockaddr_in>() as libc::socklen_t,
)
};
if bind_result != 0 {
let error = std::io::Error::last_os_error();
unsafe {
libc::close(fd);
}
return Err(format!(
"Failed to bind LPD socket to {}: {}",
bind_addr, error
));
}
let socket = unsafe { UdpSocket::from_raw_fd(fd) };
socket
.join_multicast_v4(&multicast_ip, &Ipv4Addr::UNSPECIFIED)
.map_err(|e| format!("Failed to join LPD multicast group: {}", e))?;
debug!(local = ?socket.local_addr().ok(), "LPD receive socket created (Unix)");
Ok(socket)
}
#[cfg(windows)]
{
let bind_addr = SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, port);
let socket = UdpSocket::bind(bind_addr)
.map_err(|e| format!("Failed to bind LPD socket to {}: {}", bind_addr, e))?;
socket
.join_multicast_v4(&multicast_ip, &Ipv4Addr::UNSPECIFIED)
.map_err(|e| format!("Failed to join LPD multicast group: {}", e))?;
debug!(local = ?socket.local_addr().ok(), "LPD receive socket created (Windows)");
Ok(socket)
}
#[cfg(not(any(unix, windows)))]
{
let bind_addr = SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, port);
let socket =
UdpSocket::bind(bind_addr).map_err(|e| format!("Failed to bind LPD socket: {}", e))?;
socket
.join_multicast_v4(&multicast_ip, &Ipv4Addr::UNSPECIFIED)
.map_err(|e| format!("Failed to join LPD multicast group: {}", e))?;
Ok(socket)
}
}
async fn run_receive_loop(
socket: tokio::net::UdpSocket,
peers: Arc<RwLock<HashMap<String, HashSet<LpdPeer>>>>,
active_hashes: Arc<RwLock<HashSet<String>>>,
cancel_token: CancellationToken,
) {
let mut buf = [0u8; LPD_BUFFER_SIZE];
info!("LPD receive loop entered");
loop {
let recv_result = tokio::select! {
result = socket.recv_from(&mut buf) => result,
_ = cancel_token.cancelled() => {
info!("LPD receive loop cancelled");
break;
}
};
let (len, src_addr) = match recv_result {
Ok(r) => r,
Err(e) => {
warn!(error = %e, "LPD receive socket error, retrying");
tokio::time::sleep(Duration::from_millis(50)).await;
continue;
}
};
if len == 0 {
continue;
}
let mut batch = Vec::with_capacity(MAX_MESSAGES_PER_ITERATION);
if let Some(peer) = parse_lpd_announcement(&buf[..len], src_addr.ip()) {
trace!(
info_hash = %&peer.info_hash[..8.min(peer.info_hash.len())],
port = peer.port, addr = %src_addr.ip(),
"LPD receive: valid announcement"
);
batch.push(peer);
}
for _ in 1..MAX_MESSAGES_PER_ITERATION {
match socket.try_recv_from(&mut buf) {
Ok((n, addr)) if n > 0 => {
if let Some(p) = parse_lpd_announcement(&buf[..n], addr.ip()) {
batch.push(p);
}
}
Ok(_) => continue,
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
Err(e) => {
warn!(error = %e, "LPD batch recv error");
break;
}
}
}
if !batch.is_empty() {
update_peer_registry(&peers, &active_hashes, batch).await;
}
}
info!("LPD receive loop exited");
}
async fn update_peer_registry(
peers: &Arc<RwLock<HashMap<String, HashSet<LpdPeer>>>>,
active_hashes: &Arc<RwLock<HashSet<String>>>,
new_peers: Vec<LpdPeer>,
) {
let active = active_hashes.read().await;
let relevant_peers: Vec<LpdPeer> = new_peers
.into_iter()
.filter(|p| active.contains(&p.info_hash))
.collect();
drop(active);
if relevant_peers.is_empty() {
return;
}
let mut peers_map = peers.write().await;
for peer in relevant_peers {
let entry = peers_map.entry(peer.info_hash.clone()).or_default();
if entry.len() >= crate::engine::lpd_manager::MAX_PEERS_PER_HASH
&& let Some(oldest) = entry.iter().max_by_key(|p| p.last_seen.elapsed()).cloned()
{
entry.remove(&oldest);
}
if entry.insert(peer.clone()) {
debug!(
info_hash = %&peer.info_hash[..8.min(peer.info_hash.len())],
addr = %peer.addr,
port = peer.port,
local = peer.is_local,
"LPD peer added to registry"
);
} else {
trace!(
info_hash = %&peer.info_hash[..8.min(peer.info_hash.len())],
addr = %peer.addr,
"LPD peer already in registry (updated last_seen)"
);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{IpAddr, Ipv4Addr};
#[test]
fn test_create_lpd_socket() {
match create_lpd_socket() {
Ok(socket) => {
let local = socket.local_addr().expect("local_addr should work");
assert_eq!(local.port(), constants::LPD_PORT);
debug!(addr = %local, "LPD socket created successfully");
}
Err(e) => {
eprintln!("SKIP: create_lpd_socket failed: {}", e);
}
}
}
#[test]
fn test_lpd_buffer_size() {
assert_eq!(
LPD_BUFFER_SIZE,
constants::LPD_RECEIVE_BUFFER_SIZE,
"LPD_BUFFER_SIZE should match constants::LPD_RECEIVE_BUFFER_SIZE"
);
}
#[test]
fn test_max_messages_per_iteration() {
assert_eq!(MAX_MESSAGES_PER_ITERATION, 20, "Should match C++ constant");
}
#[tokio::test]
async fn test_update_peer_registry_filters_unknown_hashes() {
let peers: Arc<RwLock<HashMap<String, HashSet<LpdPeer>>>> =
Arc::new(RwLock::new(HashMap::new()));
let active_hashes: Arc<RwLock<HashSet<String>>> = Arc::new(RwLock::new(HashSet::new()));
{
let mut active = active_hashes.write().await;
active.insert("0123456789abcdef0123456789abcdef01234567".to_string());
}
let new_peers = vec![
LpdPeer::new(
"0123456789abcdef0123456789abcdef01234567",
6881,
IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)),
),
LpdPeer::new(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
6882,
IpAddr::V4(Ipv4Addr::new(10, 0, 0, 2)),
),
];
update_peer_registry(&peers, &active_hashes, new_peers).await;
let peers_map = peers.read().await;
assert!(
peers_map.contains_key("0123456789abcdef0123456789abcdef01234567"),
"Known hash should be present"
);
assert!(
!peers_map.contains_key("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
"Unknown hash should be filtered out"
);
}
#[tokio::test]
async fn test_update_peer_registry_max_peers() {
let peers: Arc<RwLock<HashMap<String, HashSet<LpdPeer>>>> =
Arc::new(RwLock::new(HashMap::new()));
let active_hashes: Arc<RwLock<HashSet<String>>> = Arc::new(RwLock::new(HashSet::new()));
let info_hash = "0123456789abcdef0123456789abcdef01234567";
{
let mut active = active_hashes.write().await;
active.insert(info_hash.to_string());
}
let new_peers: Vec<LpdPeer> = (0..crate::engine::lpd_manager::MAX_PEERS_PER_HASH + 5)
.map(|i| {
LpdPeer::new(
info_hash,
6881,
IpAddr::V4(Ipv4Addr::new(10, 0, (i / 256) as u8, (i % 256) as u8)),
)
})
.collect();
update_peer_registry(&peers, &active_hashes, new_peers).await;
let peers_map = peers.read().await;
let stored = peers_map.get(info_hash).expect("hash should exist");
assert!(
stored.len() <= crate::engine::lpd_manager::MAX_PEERS_PER_HASH,
"Should not exceed MAX_PEERS_PER_HASH (got {})",
stored.len()
);
}
#[tokio::test]
async fn test_lpd_receive_loop_lifecycle() {
let mut recv_loop = LpdReceiveLoop::new();
assert!(!recv_loop.is_running(), "Should not be running initially");
let peers: Arc<RwLock<HashMap<String, HashSet<LpdPeer>>>> =
Arc::new(RwLock::new(HashMap::new()));
let active_hashes: Arc<RwLock<HashSet<String>>> = Arc::new(RwLock::new(HashSet::new()));
match recv_loop.start(peers, active_hashes).await {
Ok(()) => {
assert!(recv_loop.is_running(), "Should be running after start");
recv_loop.stop().await;
assert!(!recv_loop.is_running(), "Should not be running after stop");
}
Err(e) => {
eprintln!("SKIP: LPD receive loop start failed: {}", e);
}
}
}
}