use std::collections::{HashMap, HashSet};
use std::net::SocketAddr;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use tokio::net::TcpStream;
use tokio::sync::mpsc;
use tokio::sync::RwLock;
use tracing::{debug, info, warn};
use crate::config::Config;
use crate::dht::DhtNode;
use crate::error::{Error, Result};
use crate::inbound::InboundHandler;
use crate::net::{DialGate, RateLimiter};
use crate::peer::{Handshake, PeerConnection, PeerId};
use crate::secure::{
Handoff, PeerEndpointStore, SecureEnv, SecureNode, SecureNodeConfig, SecurePolicy, TlsMaterial,
};
use crate::session::{run_download, run_seed, Session};
use crate::torrent::{InfoHash, MagnetLink, TorrentFile};
use crate::utp::UtpEndpoint;
mod mse_heal;
use mse_heal::{MseHealBackoff, MseHealOutcome, MseHealState, MSE_HEAL_MAX_BACKOFF};
struct TorrentSlot {
session: Arc<Session>,
inbound: RwLock<Option<Arc<dyn InboundHandler>>>,
}
pub struct Client {
cfg: Arc<Config>,
peer_id: PeerId,
dht: Option<Arc<DhtNode>>,
slots: RwLock<HashMap<InfoHash, TorrentSlot>>,
reconnect_pending: Mutex<HashMap<SocketAddr, HashSet<InfoHash>>>,
reconnect_inflight: Mutex<HashSet<SocketAddr>>,
services_started: AtomicBool,
download_limiter: RateLimiter,
upload_limiter: RateLimiter,
secure: Arc<SecureNode>,
utp: tokio::sync::OnceCell<Arc<UtpEndpoint>>,
mse_heal: MseHealState,
_nat: RwLock<Vec<crate::nat::PortMapping>>,
}
impl Client {
pub async fn open(cfg: Config) -> Result<Arc<Self>> {
SecureEnv::check_required()?;
let tls = SecureEnv::tls_from_env()?;
let policy = Arc::new(crate::secure::EnvSecurePolicy::from_env_with_tls(&tls)?);
let handshake_key = SecureEnv::handshake_key().ok_or_else(|| {
Error::Secure(format!("missing env {}", SecureEnv::HANDSHAKE_KEY))
})?;
Self::open_secure_with_handshake(cfg, policy, tls, handshake_key).await
}
pub async fn open_secure(
cfg: Config,
policy: Arc<dyn SecurePolicy>,
tls: TlsMaterial,
) -> Result<Arc<Self>> {
let handshake_key = SecureEnv::handshake_key().ok_or_else(|| {
Error::Secure(format!(
"missing env {} (required for sealed credential channel)\n\n{}",
SecureEnv::HANDSHAKE_KEY,
SecureEnv::required_env_help()
))
})?;
Self::open_secure_with_handshake(cfg, policy, tls, handshake_key).await
}
pub async fn open_secure_with_handshake(
mut cfg: Config,
policy: Arc<dyn SecurePolicy>,
tls: TlsMaterial,
handshake_key: Vec<u8>,
) -> Result<Arc<Self>> {
if handshake_key.is_empty() {
return Err(Error::Secure("handshake key must not be empty".into()));
}
if handshake_key.len() < SecureEnv::MIN_HANDSHAKE_KEY_LEN {
return Err(Error::Secure(format!(
"handshake key must be at least {} bytes (got {})",
SecureEnv::MIN_HANDSHAKE_KEY_LEN,
handshake_key.len()
)));
}
if cfg.state_dir.is_none() {
if let Some(dir) = SecureEnv::state_dir() {
cfg.state_dir = Some(dir);
}
}
if let Some(state) = &cfg.state_dir {
crate::layout::ensure_host_dir(state)?;
}
crate::layout::ensure_host_dir(&cfg.download_dir)?;
if cfg.integrity_access_secret.is_none() {
cfg.integrity_access_secret = Some(zeroize::Zeroizing::new(handshake_key.clone()));
}
if let Some(addr) = SecureEnv::listen_addr() {
let listen: SocketAddr = addr
.parse()
.map_err(|err| Error::Secure(format!("TORRENTDHT_LISTEN_ADDR: {err}")))?;
if cfg.listen_port != listen.port() {
tracing::warn!(
kdl_port = cfg.listen_port,
env_port = listen.port(),
"TORRENTDHT_LISTEN_ADDR overrides listen-port from config"
);
}
cfg.listen_port = listen.port();
}
crate::rpc::validate_rpc_config(&cfg)?;
crate::torrent::validate_signed_torrent_config(&cfg)?;
crate::swarm::validate_swarm_stack(&cfg)?;
if cfg.dht_enabled && cfg.dht_bootstrap.is_empty() {
tracing::warn!(
"dht-bootstrap is empty — using public Mainline routers; \
TORRENTDHT_NETWORK_ID is capability-bearing (SHA-1 announced). \
For proprietary networks set private dht-bootstrap nodes \
(see config/commercial.kdl)."
);
}
let cfg = Arc::new(cfg);
let peer_id = random_peer_id()?;
let dht = if cfg.dht_enabled {
Some(Arc::new(DhtNode::bind(&cfg).await?))
} else {
None
};
let nat = if cfg.nat_enabled {
crate::nat::map_listen_ports(
cfg.listen_port,
cfg.nat_map_tcp,
cfg.nat_map_udp,
cfg.nat_upnp,
cfg.nat_natpmp,
)
.await?
} else {
Vec::new()
};
let listen: SocketAddr = if let Some(addr) = SecureEnv::listen_addr() {
addr.parse()
.map_err(|err| Error::Secure(format!("TORRENTDHT_LISTEN_ADDR: {err}")))?
} else {
format!("0.0.0.0:{}", cfg.listen_port)
.parse()
.map_err(|err| Error::Secure(format!("listen addr: {err}")))?
};
let secure_cfg = SecureNodeConfig {
listen_addr: listen,
peer_store: peer_store_for(&cfg)?,
handshake_key: Some(zeroize::Zeroizing::new(handshake_key)),
reconnect_backoff_initial: std::time::Duration::from_secs(1),
reconnect_backoff_max: std::time::Duration::from_secs(60),
enable_dht: cfg.dht_enabled,
listen_dual_stack: cfg.listen_dual_stack,
block_private: cfg.tracker_block_private,
connect_timeout: std::time::Duration::from_secs(cfg.secure_connect_timeout_secs.max(1)),
tls_timeout: std::time::Duration::from_secs(cfg.secure_tls_timeout_secs.max(1)),
handshake_timeout: std::time::Duration::from_secs(
cfg.secure_handshake_timeout_secs.max(1),
),
};
let secure = SecureNode::new(policy, tls, secure_cfg, dht.clone()).await?;
let client = Arc::new(Self {
cfg: cfg.clone(),
peer_id,
dht,
slots: RwLock::new(HashMap::new()),
reconnect_pending: Mutex::new(HashMap::new()),
reconnect_inflight: Mutex::new(HashSet::new()),
services_started: AtomicBool::new(false),
download_limiter: RateLimiter::new(cfg.download_rate_kbps),
upload_limiter: RateLimiter::new(cfg.upload_rate_kbps),
secure: Arc::clone(&secure),
utp: tokio::sync::OnceCell::new(),
mse_heal: MseHealState::new(),
_nat: RwLock::new(nat),
});
client.ensure_services();
tokio::task::yield_now().await;
if let Some(dht) = &client.dht {
dht.bootstrap(&[]).await?;
}
let handoff_rx = secure.subscribe_handoffs().await?;
let handoff_client = Arc::clone(&client);
tokio::spawn(async move {
run_reconnect_handoff_loop(handoff_client, handoff_rx).await;
});
let accept_client = Arc::clone(&client);
tokio::spawn(async move {
if let Err(err) = run_secure_accept_loop(accept_client).await {
warn!(%err, "secure accept loop exited");
}
});
let reconnect = Arc::clone(&secure);
tokio::spawn(async move {
if let Err(err) = reconnect.run_reconnect_loop().await {
warn!(%err, "secure reconnect loop exited");
}
});
Ok(client)
}
pub fn config(&self) -> &Config {
&self.cfg
}
pub fn peer_id(&self) -> PeerId {
self.peer_id
}
pub fn download_limiter(&self) -> &RateLimiter {
&self.download_limiter
}
pub fn upload_limiter(&self) -> &RateLimiter {
&self.upload_limiter
}
pub async fn persist_dht(&self) -> Result<()> {
if let Some(dht) = &self.dht {
dht.persist_routing_table(&self.cfg).await?;
}
Ok(())
}
pub fn dht(&self) -> Option<Arc<DhtNode>> {
self.dht.as_ref().map(Arc::clone)
}
pub fn secure_node(&self) -> Arc<SecureNode> {
Arc::clone(&self.secure)
}
pub fn subscribe_handoff_notices(
&self,
) -> tokio::sync::broadcast::Receiver<crate::secure::HandoffNotice> {
self.secure.subscribe_handoff_notices()
}
pub async fn secure_dial(self: &Arc<Self>, addr: SocketAddr) -> Result<Handoff> {
self.secure.dial(addr).await
}
pub async fn secure_dial_host(self: &Arc<Self>, addr: SocketAddr) -> Result<Handoff> {
self.secure.dial_host_approved(addr).await
}
pub async fn secure_dial_hostname(
self: &Arc<Self>,
host: &str,
addr: SocketAddr,
) -> Result<Handoff> {
self.secure.dial_hostname(host, addr).await
}
pub async fn dial_torrent_peer(
self: &Arc<Self>,
addr: SocketAddr,
info_hash: InfoHash,
extensions: bool,
) -> Result<PeerConnection> {
self.dial_torrent_peer_inner(addr, info_hash, extensions, false)
.await
}
pub async fn dial_torrent_peer_host(
self: &Arc<Self>,
addr: SocketAddr,
info_hash: InfoHash,
extensions: bool,
) -> Result<PeerConnection> {
self.dial_torrent_peer_inner(addr, info_hash, extensions, true)
.await
}
pub async fn utp_endpoint(self: &Arc<Self>) -> Result<Arc<UtpEndpoint>> {
self.utp
.get_or_try_init(|| async {
let local = SocketAddr::from(([0, 0, 0, 0], 0));
let endpoint = crate::utp::bind_utp(local).await?;
Ok::<_, Error>(Arc::new(endpoint))
})
.await
.map(Arc::clone)
}
async fn dial_torrent_peer_inner(
self: &Arc<Self>,
addr: SocketAddr,
info_hash: InfoHash,
extensions: bool,
host_approved: bool,
) -> Result<PeerConnection> {
crate::swarm::validate_swarm_stack(self.config())?;
let gate = DialGate::from_block_private(self.cfg.tracker_block_private);
if host_approved {
} else {
gate.ensure_dialable(addr)?;
}
let stack = crate::swarm::SwarmStack::from_config(self.config());
let handshake = if extensions {
Handshake::new(info_hash, self.peer_id).with_swarm_features()
} else {
Handshake::new(info_hash, self.peer_id)
};
match stack.backend() {
crate::swarm::SwarmBackend::MtlsTcp => {
let handoff = if host_approved {
self.secure_dial_host(addr).await?
} else {
self.secure_dial(addr).await?
};
PeerConnection::from_secure_initiator(handoff, &handshake).await
}
crate::swarm::SwarmBackend::MseTcp => {
let connect_timeout =
std::time::Duration::from_secs(self.cfg.secure_connect_timeout_secs.max(1));
let stream = tokio::time::timeout(connect_timeout, TcpStream::connect(addr))
.await
.map_err(|_| Error::Peer(format!("MSE TCP connect timed out for {addr}")))?
.map_err(Error::from)?;
let mse = crate::mse::dial_mse(stream, info_hash.as_bytes()).await?;
let conn =
PeerConnection::from_mse_initiator(addr, mse, &handshake).await?;
self.pin_mse_peer(addr, info_hash, conn.remote_peer_id)
.await;
Ok(conn)
}
crate::swarm::SwarmBackend::MseUtp => {
let endpoint = self.utp_endpoint().await?;
let utp = crate::utp::connect(endpoint.as_ref(), addr).await?;
let peer = utp.peer_addr();
let mse = crate::mse::dial_mse_utp(utp, info_hash.as_bytes()).await?;
let conn =
PeerConnection::from_mse_initiator(peer, mse, &handshake).await?;
self.pin_mse_peer(peer, info_hash, conn.remote_peer_id)
.await;
Ok(conn)
}
crate::swarm::SwarmBackend::Invalid => Err(Error::Config(format!(
"unsupported swarm stack {}",
stack.describe()
))),
}
}
pub fn signal_peer_broken(self: &Arc<Self>, peer_addr: SocketAddr, info_hash: InfoHash) {
{
let mut pending = self
.reconnect_pending
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
pending.entry(peer_addr).or_default().insert(info_hash);
}
let should_start = {
let mut inflight = self
.reconnect_inflight
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
inflight.insert(peer_addr)
};
if !should_start {
return;
}
let stack = crate::swarm::SwarmStack::from_config(self.config());
match stack.backend() {
crate::swarm::SwarmBackend::MtlsTcp => {
self.secure.signal_broken_preferred(peer_addr);
let client = Arc::clone(self);
tokio::spawn(async move {
tokio::time::sleep(std::time::Duration::from_secs(120)).await;
let mut inflight = client
.reconnect_inflight
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
inflight.remove(&peer_addr);
});
}
crate::swarm::SwarmBackend::MseTcp | crate::swarm::SwarmBackend::MseUtp => {
let client = Arc::clone(self);
tokio::spawn(async move {
reconnect_mse_swarm_peer(client, peer_addr).await;
});
}
crate::swarm::SwarmBackend::Invalid => {
let mut inflight = self
.reconnect_inflight
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
inflight.remove(&peer_addr);
}
}
}
pub async fn pin_mse_peer(&self, addr: SocketAddr, info_hash: InfoHash, peer_id: PeerId) {
self.mse_heal.pin(addr, info_hash, peer_id).await;
}
async fn mse_heal_eligible(&self, addr: SocketAddr, info_hash: InfoHash) -> bool {
let slots = self.slots.read().await;
let Some(slot) = slots.get(&info_hash) else {
return false;
};
if slot.session.is_static_peer(addr).await {
return true;
}
self.mse_heal.pinned_id(addr, info_hash).await.is_some()
}
pub async fn torrent_over_secure_acceptor(
self: &Arc<Self>,
handoff: Handoff,
) -> Result<(PeerConnection, InfoHash)> {
crate::swarm::validate_swarm_stack(self.config())?;
let stack = crate::swarm::SwarmStack::from_config(self.config());
match stack.backend() {
crate::swarm::SwarmBackend::MtlsTcp => {
PeerConnection::from_secure_acceptor(handoff, self.peer_id, None).await
}
crate::swarm::SwarmBackend::MseTcp
| crate::swarm::SwarmBackend::MseUtp
| crate::swarm::SwarmBackend::Invalid => Err(Error::Config(
"torrent_over_secure_acceptor is mTLS-only; use accept_mse_torrent_peer / accept_mse_utp_peer"
.into(),
)),
}
}
pub async fn accept_mse_torrent_peer(
self: &Arc<Self>,
stream: TcpStream,
peer_addr: SocketAddr,
expected: InfoHash,
) -> Result<(PeerConnection, InfoHash)> {
crate::swarm::validate_swarm_stack(self.config())?;
let stack = crate::swarm::SwarmStack::from_config(self.config());
if stack.backend() != crate::swarm::SwarmBackend::MseTcp {
return Err(Error::Config(
"accept_mse_torrent_peer requires swarm-security \"mse\" and swarm-transport \"tcp\""
.into(),
));
}
let mse = crate::mse::accept_mse(stream, expected.as_bytes()).await?;
let (conn, hash) =
PeerConnection::from_mse_acceptor(peer_addr, mse, self.peer_id, Some(expected)).await?;
self.pin_mse_peer(peer_addr, hash, conn.remote_peer_id).await;
Ok((conn, hash))
}
pub async fn accept_mse_utp_peer(
self: &Arc<Self>,
stream: crate::utp::UtpStream,
expected: InfoHash,
) -> Result<(PeerConnection, InfoHash)> {
crate::swarm::validate_swarm_stack(self.config())?;
let stack = crate::swarm::SwarmStack::from_config(self.config());
if stack.backend() != crate::swarm::SwarmBackend::MseUtp {
return Err(Error::Config(
"accept_mse_utp_peer requires swarm-security \"mse\" and swarm-transport \"utp\""
.into(),
));
}
let peer_addr = stream.peer_addr();
let mse = crate::mse::accept_mse_utp(stream, expected.as_bytes()).await?;
let (conn, hash) =
PeerConnection::from_mse_acceptor(peer_addr, mse, self.peer_id, Some(expected)).await?;
self.pin_mse_peer(peer_addr, hash, conn.remote_peer_id).await;
Ok((conn, hash))
}
pub async fn add_torrent(self: &Arc<Self>, torrent: TorrentFile) -> Result<Arc<Session>> {
let hash = torrent.info.info_hash;
if self.slots.read().await.contains_key(&hash) {
return Err(Error::Session(format!(
"torrent {} already loaded",
hash.to_hex()
)));
}
Self::validate_torrent(&self.cfg, &torrent)?;
let session = Arc::new(Session::from_torrent_with_client(Arc::clone(self), torrent).await?);
self.slots.write().await.insert(
hash,
TorrentSlot {
session: Arc::clone(&session),
inbound: RwLock::new(None),
},
);
if let Some(dht) = &self.dht {
if self.cfg.peer_discovery.uses_dht() && !session.info().private {
dht.register_swarm(session.info_hash().as_bytes()).await;
}
}
Ok(session)
}
pub async fn add_magnet(self: &Arc<Self>, magnet: MagnetLink) -> Result<Arc<Session>> {
crate::torrent::ensure_magnet_allowed(&self.cfg)?;
if self.slots.read().await.contains_key(&magnet.info_hash) {
return Err(Error::Session(format!(
"torrent {} already loaded",
magnet.info_hash.to_hex()
)));
}
let session = Arc::new(
Session::from_magnet_with_client(Arc::clone(self), magnet).await?,
);
self.slots.write().await.insert(
session.info_hash(),
TorrentSlot {
session: Arc::clone(&session),
inbound: RwLock::new(None),
},
);
if let Some(dht) = &self.dht {
if self.cfg.peer_discovery.uses_dht() && !session.info().private {
dht.register_swarm(session.info_hash().as_bytes()).await;
}
}
Ok(session)
}
pub async fn session(&self, hash: InfoHash) -> Option<Arc<Session>> {
self.slots
.read()
.await
.get(&hash)
.map(|slot| Arc::clone(&slot.session))
}
pub async fn sessions(&self) -> Vec<Arc<Session>> {
self.slots
.read()
.await
.values()
.map(|slot| Arc::clone(&slot.session))
.collect()
}
pub async fn register_inbound(&self, hash: InfoHash, handler: Arc<dyn InboundHandler>) {
if let Some(slot) = self.slots.read().await.get(&hash) {
*slot.inbound.write().await = Some(handler);
}
}
pub async fn unregister_inbound(&self, hash: InfoHash) {
if let Some(slot) = self.slots.read().await.get(&hash) {
*slot.inbound.write().await = None;
}
}
pub async fn remove_torrent(&self, hash: InfoHash) {
if let Some(slot) = self.slots.read().await.get(&hash) {
slot.session.request_stop();
slot.session.announce_stopped().await;
}
self.unregister_inbound(hash).await;
if let Some(dht) = &self.dht {
dht.unregister_swarm(hash.as_bytes()).await;
}
self.slots.write().await.remove(&hash);
}
pub async fn stop_torrent(&self, hash: InfoHash) -> bool {
let slots = self.slots.read().await;
let Some(slot) = slots.get(&hash) else {
return false;
};
let session = Arc::clone(&slot.session);
drop(slots);
session.request_stop();
self.unregister_inbound(hash).await;
session.announce_stopped().await;
true
}
pub async fn download(&self, session: Arc<Session>) -> Result<crate::session::DownloadProgress> {
run_download(session).await
}
pub async fn seed(&self, session: Arc<Session>) -> Result<()> {
run_seed(session).await
}
fn validate_torrent(cfg: &Config, torrent: &TorrentFile) -> Result<()> {
crate::torrent::ensure_torrent_trusted(cfg, torrent)
}
fn ensure_services(self: &Arc<Self>) {
if self
.services_started
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
.is_err()
{
return;
}
if let Some(dht) = self.dht.clone() {
tokio::spawn(async move {
if let Err(err) = dht.run().await {
tracing::error!(%err, "shared dht loop exited");
}
});
}
if let Some(dht) = self.dht.clone() {
tokio::spawn(async move {
dht.run_maintenance().await;
});
}
info!("swarm peer I/O gated by mTLS SecureNode handoff");
if let Some(dht) = self.dht.clone() {
if self.cfg.dht_persist {
let cfg = Arc::clone(&self.cfg);
tokio::spawn(async move {
let mut interval = tokio::time::interval(std::time::Duration::from_secs(120));
interval.tick().await;
loop {
interval.tick().await;
if let Err(err) = dht.persist_routing_table(&cfg).await {
debug!(%err, "dht routing snapshot failed");
}
}
});
}
}
if self.cfg.rpc_enabled {
let client = Arc::clone(self);
tokio::spawn(async move {
if let Err(err) = crate::rpc::serve(client).await {
warn!(%err, "rpc server exited");
}
});
}
}
}
fn random_peer_id() -> Result<PeerId> {
let mut id = [0u8; 20];
id[..8].copy_from_slice(b"-TD0001-");
let random = crate::net::random_bytes::<12>().map_err(|err| {
Error::Config(format!("CSPRNG failure generating peer id: {err}"))
})?;
id[8..].copy_from_slice(&random);
Ok(id)
}
fn peer_store_for(cfg: &Config) -> Result<PeerEndpointStore> {
let mut store = if let Some(path) = crate::secure::SecureEnv::peer_store_path() {
if let Some(parent) = path.parent() {
crate::layout::ensure_host_dir(parent)?;
}
let state_root = cfg.client_state_root();
if path
.parent()
.is_some_and(|p| p == state_root.as_path())
{
let name = path
.file_name()
.map(std::path::PathBuf::from)
.unwrap_or_else(|| std::path::PathBuf::from("peers.kdl"));
PeerEndpointStore::under_root(state_root, name)?
} else {
PeerEndpointStore::new(path)
}
} else {
let (jail, relative) = cfg.client_state_file("peers.kdl");
crate::layout::ensure_host_dir(&jail)?;
PeerEndpointStore::under_root(jail, relative)?
};
match crate::integrity::host_state_integrity(cfg) {
Ok(integrity) => {
store = store.with_integrity(integrity);
}
Err(err) if cfg.integrity_encrypt_sidecars => {
return Err(Error::Secure(format!(
"peer store requires host integrity when encrypt-sidecars is on: {err}"
)));
}
Err(_) => {}
}
Ok(store)
}
async fn reconnect_mse_swarm_peer(client: Arc<Client>, peer_addr: SocketAddr) {
let mut pending = {
let mut map = client
.reconnect_pending
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
map.remove(&peer_addr).unwrap_or_default()
};
let clear_inflight = || {
let mut inflight = client
.reconnect_inflight
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
inflight.remove(&peer_addr);
};
let Some(info_hash) = pending.iter().next().copied() else {
debug!(%peer_addr, "MSE reconnect with no pending torrents");
clear_inflight();
return;
};
pending.remove(&info_hash);
let outcome = match run_mse_heal_cycle(&client, peer_addr, info_hash).await {
Ok(outcome) => outcome,
Err(err) => {
debug!(%err, %peer_addr, "MSE heal cycle error");
MseHealOutcome::GaveUp
}
};
clear_inflight();
match outcome {
MseHealOutcome::Recovered => {
for leftover in pending {
client.signal_peer_broken(peer_addr, leftover);
}
}
MseHealOutcome::Ineligible | MseHealOutcome::GaveUp => {
if !pending.is_empty() {
let mut map = client
.reconnect_pending
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
map.entry(peer_addr).or_default().extend(pending);
}
warn!(
%peer_addr,
hash = %info_hash.to_hex(),
?outcome,
"MSE prefer-addr heal stopped without recovery"
);
}
}
}
async fn run_mse_heal_cycle(
client: &Arc<Client>,
peer_addr: SocketAddr,
info_hash: InfoHash,
) -> Result<MseHealOutcome> {
if !client.mse_heal_eligible(peer_addr, info_hash).await {
warn!(
%peer_addr,
hash = %info_hash.to_hex(),
"MSE heal refused: peer is neither static nor peer_id-pinned"
);
return Ok(MseHealOutcome::Ineligible);
}
let expected_pin = client.mse_heal.pinned_id(peer_addr, info_hash).await;
let mut backoff = MseHealBackoff::new();
loop {
match client
.dial_torrent_peer_host(peer_addr, info_hash, true)
.await
{
Ok(conn) => {
if let Some(pin) = expected_pin {
if conn.remote_peer_id != pin {
warn!(
%peer_addr,
"MSE heal peer_id mismatch; refusing re-admit"
);
let _ = client.mse_heal.forget(peer_addr, info_hash).await;
return Ok(MseHealOutcome::GaveUp);
}
} else {
client
.pin_mse_peer(peer_addr, info_hash, conn.remote_peer_id)
.await;
}
let handler = {
let slots = client.slots.read().await;
match slots.get(&info_hash) {
Some(slot) => slot.inbound.read().await.clone(),
None => None,
}
};
if let Some(handler) = handler {
handler.spawn_secure_connected(conn);
return Ok(MseHealOutcome::Recovered);
}
debug!(
%peer_addr,
hash = %info_hash.to_hex(),
"MSE reconnect: no inbound handler for info-hash"
);
return Ok(MseHealOutcome::GaveUp);
}
Err(err) => {
debug!(%err, %peer_addr, backoff = ?backoff.current(), "MSE reconnect dial failed");
if backoff.note_failure() {
warn!(
%peer_addr,
"MSE prefer-addr heal gave up after max backoff retries"
);
return Ok(MseHealOutcome::GaveUp);
}
tokio::time::sleep(backoff.current().min(MSE_HEAL_MAX_BACKOFF)).await;
}
}
}
}
async fn run_reconnect_handoff_loop(
client: Arc<Client>,
mut rx: mpsc::UnboundedReceiver<Handoff>,
) {
while let Some(handoff) = rx.recv().await {
let peer_addr = handoff.peer_addr;
let mut pending = {
let mut map = client
.reconnect_pending
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
map.remove(&peer_addr).unwrap_or_default()
};
{
let mut inflight = client
.reconnect_inflight
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
inflight.remove(&peer_addr);
}
let Some(info_hash) = pending.iter().next().copied() else {
debug!(%peer_addr, "reconnect handoff with no pending torrents");
continue;
};
pending.remove(&info_hash);
for leftover in pending {
client.signal_peer_broken(peer_addr, leftover);
}
let handshake = Handshake::new(info_hash, client.peer_id()).with_swarm_features();
match PeerConnection::from_secure_initiator(handoff, &handshake).await {
Ok(conn) => {
let handler = {
let slots = client.slots.read().await;
match slots.get(&info_hash) {
Some(slot) => slot.inbound.read().await.clone(),
None => None,
}
};
if let Some(handler) = handler {
handler.spawn_secure_connected(conn);
} else {
debug!(
%peer_addr,
hash = %info_hash.to_hex(),
"reconnect handoff: no inbound handler for info-hash"
);
}
}
Err(err) => {
debug!(%err, %peer_addr, "reconnect BT handshake failed");
client.signal_peer_broken(peer_addr, info_hash);
}
}
}
}
async fn run_secure_accept_loop(client: Arc<Client>) -> Result<()> {
loop {
match client.secure.accept_once().await {
Ok(handoff) => {
let peer_addr = handoff.peer_addr;
let client = Arc::clone(&client);
tokio::spawn(async move {
match client.torrent_over_secure_acceptor(handoff).await {
Ok((conn, hash)) => {
let handler = {
let slots = client.slots.read().await;
match slots.get(&hash) {
Some(slot) => slot.inbound.read().await.clone(),
None => None,
}
};
if let Some(handler) = handler {
handler.spawn_secure_connected(conn);
} else {
debug!(
%peer_addr,
hash = %hash.to_hex(),
"secure handoff: no inbound handler for info-hash"
);
}
}
Err(err) => debug!(%err, %peer_addr, "secure BT accept failed"),
}
});
}
Err(err) => {
debug!(%err, "secure accept_once failed");
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
}
}
}
}