mod announce;
mod discovery;
mod peer;
mod receive_loop;
#[cfg(test)]
mod tests;
pub use announce::LpdAnnouncer;
pub use discovery::{is_private_address, parse_lpd_announcement};
pub use peer::LpdPeer;
pub use receive_loop::LpdReceiveLoop;
use std::collections::{HashMap, HashSet};
use std::net::Ipv4Addr;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;
use tokio_util::sync::CancellationToken;
use tracing::{debug, info, warn};
use crate::constants;
pub use constants::{
LPD_DEFAULT_ANNOUNCE_INTERVAL_SECS as DEFAULT_ANNOUNCE_INTERVAL_SECS,
LPD_MULTICAST_ADDRESS as LPD_MULTICAST_ADDR, LPD_PORT,
};
pub const MAX_PEERS_PER_HASH: usize = 50;
pub struct LpdManager {
announcer: Arc<LpdAnnouncer>,
peers: Arc<RwLock<HashMap<Arc<str>, HashSet<LpdPeer>>>>,
pub active_hashes: Arc<RwLock<HashSet<Arc<str>>>>,
announce_ports: Arc<RwLock<HashMap<Arc<str>, u16>>>,
announce_task: std::sync::Mutex<Option<tokio::task::JoinHandle<()>>>,
receive_loop: tokio::sync::Mutex<LpdReceiveLoop>,
listen_port: u16,
interface: Option<Ipv4Addr>,
}
impl Default for LpdManager {
fn default() -> Self {
Self::new()
}
}
impl Drop for LpdManager {
fn drop(&mut self) {
if let Ok(mut task) = self.announce_task.lock()
&& let Some(handle) = task.take()
{
handle.abort();
}
}
}
impl LpdManager {
pub fn new() -> Self {
Self::with_interval_and_interface_and_port(
constants::LPD_DEFAULT_ANNOUNCE_INTERVAL_SECS,
None,
constants::LPD_PORT,
)
.unwrap_or_else(|_| {
warn!("Could not create LPD announcer, LPD will be disabled");
let announcer =
LpdAnnouncer::with_config(constants::LPD_DEFAULT_ANNOUNCE_INTERVAL_SECS)
.unwrap_or_else(|_| panic!("Fatal: cannot create LPD announcer"));
Self {
announcer: Arc::new(announcer),
peers: Arc::new(RwLock::new(HashMap::new())),
active_hashes: Arc::new(RwLock::new(HashSet::new())),
announce_ports: Arc::new(RwLock::new(HashMap::new())),
announce_task: std::sync::Mutex::new(None),
receive_loop: tokio::sync::Mutex::new(LpdReceiveLoop::new()),
listen_port: constants::LPD_PORT,
interface: None,
}
})
}
pub fn with_interval_and_interface_and_port(
announce_interval_secs: u64,
interface: Option<Ipv4Addr>,
listen_port: u16,
) -> Result<Self, String> {
if announce_interval_secs == 0 {
return Err("LPD announce interval must be greater than zero".to_string());
}
if listen_port == 0 {
return Err("LPD listen port must be greater than zero".to_string());
}
let announcer =
LpdAnnouncer::with_interface_and_port(announce_interval_secs, interface, listen_port)?;
Ok(Self {
announcer: Arc::new(announcer),
peers: Arc::new(RwLock::new(HashMap::new())),
active_hashes: Arc::new(RwLock::new(HashSet::new())),
announce_ports: Arc::new(RwLock::new(HashMap::new())),
announce_task: std::sync::Mutex::new(None),
receive_loop: tokio::sync::Mutex::new(LpdReceiveLoop::new()),
listen_port,
interface,
})
}
pub fn with_interval(announce_interval_secs: u64) -> Result<Self, String> {
Self::with_interval_and_interface(announce_interval_secs, None)
}
pub fn with_interval_and_interface(
announce_interval_secs: u64,
interface: Option<Ipv4Addr>,
) -> Result<Self, String> {
Self::with_interval_and_interface_and_port(
announce_interval_secs,
interface,
constants::LPD_PORT,
)
}
pub fn interface(&self) -> Option<Ipv4Addr> {
self.interface
}
pub async fn register_torrent(
&self,
info_hash: &str,
private_torrent: bool,
) -> Result<(), String> {
self.register_torrent_internal(info_hash, private_torrent, 0)
.await
}
pub async fn register_torrent_with_port(
&self,
info_hash: &str,
private_torrent: bool,
port: u16,
) -> Result<(), String> {
if port == 0 {
return Err("LPD registration requires a non-zero BitTorrent listen port".to_string());
}
self.register_torrent_internal(info_hash, private_torrent, port)
.await
}
async fn register_torrent_internal(
&self,
info_hash: &str,
private_torrent: bool,
port: u16,
) -> Result<(), String> {
if private_torrent {
debug!(
info_hash = %&info_hash[..8],
"Skipping LPD registration for private torrent (BEP 0027)"
);
return Err("Private torrents must not be announced via LPD (BEP 0027)".to_string());
}
let mut active = self.active_hashes.write().await;
let shared_hash: Arc<str> = Arc::from(info_hash);
active.insert(Arc::clone(&shared_hash));
let mut announce_ports = self.announce_ports.write().await;
announce_ports.insert(Arc::clone(&shared_hash), port);
let mut peers_map = self.peers.write().await;
peers_map.entry(shared_hash).or_default();
info!(info_hash = %&info_hash[..8], "Torrent registered for LPD");
Ok(())
}
pub async fn unregister_torrent(&self, info_hash: &str) {
let mut active = self.active_hashes.write().await;
active.remove(info_hash);
drop(active);
let mut announce_ports = self.announce_ports.write().await;
announce_ports.remove(info_hash);
drop(announce_ports);
self.peers.write().await.remove(info_hash);
info!(info_hash = %&info_hash[..8], "Torrent unregistered from LPD");
}
pub async fn announce_port_for(&self, info_hash: &str) -> Option<u16> {
self.announce_ports.read().await.get(info_hash).copied()
}
pub async fn announce_torrent(&self, info_hash: &str, port: u16) -> Result<(), String> {
self.announcer.announce(info_hash, port)?;
Ok(())
}
pub async fn discover_peers(&self, _info_hash: &str, timeout_ms: Option<u64>) -> Vec<LpdPeer> {
let timeout =
Duration::from_millis(timeout_ms.unwrap_or(constants::LPD_DEFAULT_RECEIVE_TIMEOUT_MS));
self.announcer.receive_announcements(timeout)
}
pub async fn get_peers_for(&self, info_hash: &str) -> Vec<LpdPeer> {
let peers_map = self.peers.read().await;
peers_map
.get(info_hash)
.map(|set| set.iter().cloned().collect())
.unwrap_or_default()
}
pub fn start_background_announce(
&self,
fallback_port: u16,
) -> Option<tokio::task::JoinHandle<()>> {
if !self.announcer.is_enabled() {
debug!("LPD is disabled, not starting background announce");
return None;
}
let mut task_slot = self
.announce_task
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if task_slot.is_some() {
return None;
}
let announcer = Arc::clone(&self.announcer);
let active_hashes = Arc::clone(&self.active_hashes);
let announce_ports = Arc::clone(&self.announce_ports);
let interval = self.announcer.announce_interval();
info!(
interval_secs = interval.as_secs(),
"Starting LPD background announce task"
);
let handle = tokio::spawn(async move {
let mut ticker = tokio::time::interval(interval);
loop {
ticker.tick().await;
let torrents: Vec<(Arc<str>, u16)> = {
let active = active_hashes.read().await;
let ports = announce_ports.read().await;
active
.iter()
.map(|info_hash| {
(
info_hash.clone(),
ports
.get(info_hash)
.copied()
.filter(|port| *port != 0)
.unwrap_or(fallback_port),
)
})
.collect()
};
for (info_hash, port) in &torrents {
if *port == 0 {
continue;
}
if let Err(e) = announcer.announce(info_hash, *port) {
warn!(
info_hash = %&info_hash[..8.min(info_hash.len())],
error = %e,
"Background LPD announce failed"
);
}
}
debug!(
count = torrents.len(),
"LPD background announce cycle completed"
);
}
});
*task_slot = Some(handle);
None
}
pub fn stop_background_announce(&self) {
let mut task_slot = self
.announce_task
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if let Some(handle) = task_slot.take() {
handle.abort();
info!("LPD background announce task stopped");
}
}
pub fn is_background_announce_running(&self) -> bool {
self.announce_task
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.as_ref()
.is_some_and(|handle| !handle.is_finished())
}
pub async fn ensure_runtime_started(&self) {
if !self.announcer.is_enabled() {
return;
}
let mut receive_loop = self.receive_loop.lock().await;
if !receive_loop.is_running()
&& let Err(error) = receive_loop
.start_with_config(
Arc::clone(&self.peers),
Arc::clone(&self.active_hashes),
self.listen_port,
self.interface,
)
.await
{
warn!(%error, "LPD receive loop unavailable; announcements will still be sent");
}
drop(receive_loop);
let _ = self.start_background_announce(0);
}
pub async fn start_receive_loop(&self) -> Result<(), String> {
if !self.announcer.is_enabled() {
debug!("LPD is disabled, not starting receive loop");
return Ok(());
}
self.receive_loop
.lock()
.await
.start_with_config(
Arc::clone(&self.peers),
Arc::clone(&self.active_hashes),
self.listen_port,
self.interface,
)
.await
}
pub async fn stop_receive_loop(&self) {
self.receive_loop.lock().await.stop().await;
}
pub fn is_receive_loop_running(&self) -> bool {
self.receive_loop
.try_lock()
.map(|receive_loop| receive_loop.is_running())
.unwrap_or(false)
}
pub fn receive_loop_cancellation_token(&self) -> CancellationToken {
self.receive_loop
.try_lock()
.map(|receive_loop| receive_loop.cancellation_token())
.unwrap_or_else(|_| CancellationToken::new())
}
pub async fn update_peers(&self, info_hash: &str, new_peers: Vec<LpdPeer>) {
let mut peers_map = self.peers.write().await;
let shared_hash: Arc<str> = Arc::from(info_hash);
let entry = peers_map.entry(Arc::clone(&shared_hash)).or_default();
for peer in new_peers {
let mut peer = peer;
peer.info_hash = Arc::clone(&shared_hash);
peer::insert_or_refresh_peer(entry, peer, MAX_PEERS_PER_HASH);
}
}
pub async fn cleanup_expired_peers(&self, max_age: Duration) -> usize {
let mut peers_map = self.peers.write().await;
let mut removed = 0usize;
for peers in peers_map.values_mut() {
let before = peers.len();
peers.retain(|p| !p.is_expired(max_age));
removed += before - peers.len();
}
if removed > 0 {
debug!(removed, "Cleaned up expired LPD peers");
}
removed
}
pub fn is_available(&self) -> bool {
self.announcer.is_enabled()
}
}