torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::collections::{HashMap, HashSet};
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime, UNIX_EPOCH};

use kdl::{KdlDocument, KdlNode};

use crate::config::ResilienceConfig;
use crate::error::{Error, Result};
use crate::integrity::{open_tracked, seal_tracked, IntegrityConfig, IntegrityManifest};

/// Hard cap on peer ledger map size (evict oldest `last_seen`).
const MAX_PEER_LEDGER: usize = 4096;
/// Max previously-unknown peers admitted from one discovery batch (Sybil flood brake).
const MAX_NEW_DISCOVERY_PER_CALL: usize = 32;

#[derive(Debug, Clone, Default)]
pub struct PeerRecord {
    pub failures: u32,
    pub successes: u32,
    pub last_seen: u64,
    pub last_fail: u64,
    pub banned_until: u64,
}

#[derive(Debug, Default)]
pub struct PeerLedger {
    peers: HashMap<SocketAddr, PeerRecord>,
}

impl PeerLedger {
    pub fn load(records: impl IntoIterator<Item = (SocketAddr, PeerRecord)>) -> Self {
        let mut ledger = Self {
            peers: records.into_iter().collect(),
        };
        ledger.enforce_cap();
        ledger
    }

    fn enforce_cap(&mut self) {
        while self.peers.len() > MAX_PEER_LEDGER {
            let oldest = self
                .peers
                .iter()
                .min_by_key(|(_, record)| record.last_seen)
                .map(|(addr, _)| *addr);
            if let Some(addr) = oldest {
                self.peers.remove(&addr);
            } else {
                break;
            }
        }
    }

    pub fn record_success(&mut self, addr: SocketAddr) {
        let now = unix_now();
        let entry = self.peers.entry(addr).or_default();
        entry.failures = 0;
        entry.successes = entry.successes.saturating_add(1);
        entry.last_seen = now;
        entry.banned_until = 0;
        self.enforce_cap();
    }

    pub fn record_failure(&mut self, addr: SocketAddr, cfg: &ResilienceConfig) {
        let now = unix_now();
        let entry = self.peers.entry(addr).or_default();
        entry.failures = entry.failures.saturating_add(1);
        entry.last_fail = now;
        entry.last_seen = now;
        if entry.failures >= cfg.max_peer_failures {
            entry.banned_until = now.saturating_add(cfg.peer_ban_secs);
        }
        self.enforce_cap();
    }

    /// Immediate ban after mTLS / policy rejection (Sybil IP churn brake).
    pub fn ban_now(&mut self, addr: SocketAddr, cfg: &ResilienceConfig) {
        let now = unix_now();
        let entry = self.peers.entry(addr).or_default();
        entry.failures = cfg.max_peer_failures.max(1);
        entry.last_fail = now;
        entry.last_seen = now;
        entry.banned_until = now.saturating_add(cfg.peer_ban_secs);
        self.enforce_cap();
    }

    pub fn is_available(&self, addr: SocketAddr, _cfg: &ResilienceConfig) -> bool {
        let Some(record) = self.peers.get(&addr) else {
            return true;
        };
        let now = unix_now();
        record.banned_until == 0 || now >= record.banned_until
    }

    pub fn prune_expired_bans(&mut self, cfg: &ResilienceConfig) {
        let now = unix_now();
        for record in self.peers.values_mut() {
            if record.banned_until != 0 && now >= record.banned_until {
                record.banned_until = 0;
                record.failures = record.failures.min(cfg.max_peer_failures.saturating_sub(1));
            }
        }
    }

    /// Known peers sorted for reconnect: verified successes first, then fewer failures, then recent.
    pub fn reconnect_candidates(&self, active: &HashSet<SocketAddr>) -> Vec<SocketAddr> {
        let mut candidates: Vec<_> = self
            .peers
            .iter()
            .filter(|(addr, _)| !active.contains(addr))
            .map(|(addr, record)| (*addr, record.successes, record.failures, record.last_seen))
            .collect();
        candidates.sort_by(|a, b| {
            b.1.cmp(&a.1)
                .then(a.2.cmp(&b.2))
                .then(b.3.cmp(&a.3))
        });
        candidates
            .into_iter()
            .map(|(addr, _, _, _)| addr)
            .collect()
    }

    pub fn iter(&self) -> impl Iterator<Item = (&SocketAddr, &PeerRecord)> {
        self.peers.iter()
    }

    /// Admit at most `max_new` previously-unknown discovery addresses (Sybil flood brake).
    pub fn note_discovered(&mut self, addrs: &[SocketAddr]) -> usize {
        self.note_discovered_capped(addrs, MAX_NEW_DISCOVERY_PER_CALL)
    }

    pub fn note_discovered_capped(&mut self, addrs: &[SocketAddr], max_new: usize) -> usize {
        let now = unix_now();
        let mut added = 0usize;
        for addr in addrs {
            if let Some(existing) = self.peers.get_mut(addr) {
                existing.last_seen = now;
                continue;
            }
            if added >= max_new {
                break;
            }
            self.peers.insert(
                *addr,
                PeerRecord {
                    last_seen: now,
                    ..PeerRecord::default()
                },
            );
            added = added.saturating_add(1);
        }
        self.enforce_cap();
        added
    }
}

#[derive(Debug, Clone, Default)]
pub struct ResumeCheckpoint {
    pub info_hash_hex: String,
    pub bytes_downloaded: u64,
    pub completed_pieces: HashSet<u32>,
    pub peers: HashMap<SocketAddr, PeerRecord>,
    pub saved_at: u64,
}

impl ResumeCheckpoint {
    pub fn path_for(root: &Path) -> PathBuf {
        IntegrityManifest::sidecar_dir(root).join("resume.kdl")
    }

    pub fn to_kdl(&self) -> String {
        let mut lines = vec![
            format!("info-hash \"{}\"", self.info_hash_hex),
            format!("bytes-downloaded {}", self.bytes_downloaded),
            format!("saved-at {}", self.saved_at),
            "completed-pieces {".into(),
        ];
        let mut pieces: Vec<_> = self.completed_pieces.iter().copied().collect();
        pieces.sort_unstable();
        for piece in pieces {
            lines.push(format!("    piece {piece}"));
        }
        lines.push("}".into());
        lines.push("known-peers {".into());
        for (addr, record) in &self.peers {
            lines.push(format!(
                "    peer addr=\"{addr}\" failures={} successes={} last-seen={} last-fail={} banned-until={}",
                record.failures,
                record.successes,
                record.last_seen,
                record.last_fail,
                record.banned_until
            ));
        }
        lines.push("}".into());
        lines.join("\n")
    }

    pub fn from_kdl(input: &str) -> Result<Self> {
        let doc = input
            .parse::<KdlDocument>()
            .map_err(|err| Error::Store(format!("resume parse: {err}")))?;
        let info_hash_hex = doc
            .get("info-hash")
            .and_then(|node| node.entries().first())
            .and_then(|entry| entry.value().as_string())
            .ok_or_else(|| Error::Store("resume missing info-hash".into()))?
            .to_string();
        let bytes_downloaded = doc
            .get("bytes-downloaded")
            .and_then(|node| node.entries().first())
            .and_then(|entry| entry.value().as_integer())
            .unwrap_or(0) as u64;
        let saved_at = doc
            .get("saved-at")
            .and_then(|node| node.entries().first())
            .and_then(|entry| entry.value().as_integer())
            .unwrap_or(0) as u64;

        let mut completed_pieces = HashSet::new();
        if let Some(node) = doc.get("completed-pieces").and_then(|n| n.children()) {
            for entry in node.nodes() {
                if entry.name().value() == "piece" {
                    if let Some(index) = entry.entries().first().and_then(|e| e.value().as_integer())
                    {
                        completed_pieces.insert(u32_from_kdl(index, "piece")?);
                    }
                }
            }
        }

        let mut peers = HashMap::new();
        if let Some(node) = doc.get("known-peers").and_then(|n| n.children()) {
            for entry in node.nodes() {
                if entry.name().value() != "peer" {
                    continue;
                }
                let addr = entry
                    .get("addr")
                    .and_then(|v| v.as_string())
                    .ok_or_else(|| Error::Store("peer entry missing addr".into()))?
                    .parse::<SocketAddr>()
                    .map_err(|err| Error::Store(format!("peer addr parse: {err}")))?;
                peers.insert(
                    addr,
                    PeerRecord {
                        failures: prop_u32(entry, "failures")?,
                        successes: prop_u32(entry, "successes")?,
                        last_seen: prop_u64(entry, "last-seen")?,
                        last_fail: prop_u64(entry, "last-fail")?,
                        banned_until: prop_u64(entry, "banned-until")?,
                    },
                );
            }
        }

        Ok(Self {
            info_hash_hex,
            bytes_downloaded,
            completed_pieces,
            peers,
            saved_at,
        })
    }

    pub async fn load_under_root(root: &Path, config: &IntegrityConfig) -> Result<Self> {
        let relative = Path::new(".torrentdht").join("resume.kdl");
        let stored = match crate::security::read_bytes_under_root_async(root, &relative).await {
            Ok(bytes) => bytes,
            Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {
                return Ok(Self::default());
            }
            Err(err) => return Err(err),
        };
        let context = format!("resume:{}", relative.display());
        let plain = open_tracked(config, &stored, &context)?;
        Self::from_kdl(std::str::from_utf8(&plain).map_err(|_| Error::Store("resume utf-8".into()))?)
    }

    pub async fn save_under_root(&self, root: &Path, config: &IntegrityConfig) -> Result<()> {
        let relative = Path::new(".torrentdht").join("resume.kdl");
        let kdl = self.to_kdl();
        let context = format!("resume:{}", relative.display());
        let sealed = seal_tracked(config, kdl.as_bytes(), &context)?;
        crate::security::write_bytes_under_root_async(root, &relative, sealed).await
    }

    pub async fn load(path: &Path, config: &IntegrityConfig) -> Result<Self> {
        let root = path
            .parent()
            .and_then(|p| p.parent())
            .ok_or_else(|| Error::Store("resume path missing download root".into()))?;
        Self::load_under_root(root, config).await
    }

    pub async fn save(&self, path: &Path, config: &IntegrityConfig) -> Result<()> {
        let root = path
            .parent()
            .and_then(|p| p.parent())
            .ok_or_else(|| Error::Store("resume path missing download root".into()))?;
        self.save_under_root(root, config).await
    }
}

pub fn unix_now() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or(Duration::ZERO)
        .as_secs()
}

fn prop_u32(node: &KdlNode, key: &str) -> Result<u32> {
    let value = node
        .get(key)
        .and_then(|value| value.as_integer())
        .unwrap_or(0);
    u32_from_kdl(value, key)
}

fn prop_u64(node: &KdlNode, key: &str) -> Result<u64> {
    let value = node
        .get(key)
        .and_then(|value| value.as_integer())
        .unwrap_or(0);
    if value < 0 {
        return Err(Error::Store(format!("{key} must be non-negative")));
    }
    Ok(value as u64)
}

fn u32_from_kdl(value: i128, field: &str) -> Result<u32> {
    if !(0..=u32::MAX as i128).contains(&value) {
        return Err(Error::Store(format!("{field} out of range")));
    }
    Ok(value as u32)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn peer_ledger_bans_after_failures() {
        let cfg = ResilienceConfig {
            max_peer_failures: 2,
            peer_ban_secs: 60,
            ..ResilienceConfig::default()
        };
        let addr: SocketAddr = "127.0.0.1:6882".parse().expect("addr");
        let mut ledger = PeerLedger::default();
        ledger.record_failure(addr, &cfg);
        assert!(ledger.is_available(addr, &cfg));
        ledger.record_failure(addr, &cfg);
        assert!(!ledger.is_available(addr, &cfg));
        ledger.record_success(addr);
        assert!(ledger.is_available(addr, &cfg));
    }

    #[test]
    fn resume_checkpoint_roundtrip() {
        let mut checkpoint = ResumeCheckpoint {
            info_hash_hex: "abc".into(),
            bytes_downloaded: 42,
            completed_pieces: [0, 2].into_iter().collect(),
            saved_at: 1,
            ..ResumeCheckpoint::default()
        };
        let addr: SocketAddr = "10.0.0.1:6881".parse().expect("addr");
        checkpoint.peers.insert(
            addr,
            PeerRecord {
                failures: 1,
                last_seen: 99,
                ..PeerRecord::default()
            },
        );
        let parsed = ResumeCheckpoint::from_kdl(&checkpoint.to_kdl()).expect("parse");
        assert_eq!(parsed.completed_pieces, checkpoint.completed_pieces);
        assert_eq!(parsed.bytes_downloaded, 42);
        assert_eq!(parsed.peers.get(&addr).map(|r| r.failures), Some(1));
    }
}