torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Persist last-known peer endpoints for reconnect-before-DHT.
//!
//! I/O goes through the openat jail under a host state root (same policy as
//! content/sidecars): no symlink components, regular files only.
//! When integrity config is attached, payloads are seal_tracked (HMAC or AEAD).
//!
//! Clones share one mutex so concurrent remember/save through `SecureNodeConfig`
//! clones cannot corrupt the on-disk store.

use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};

use kdl::{KdlDocument, KdlNode};

use crate::error::{Error, Result};
use crate::integrity::{open_tracked, seal_tracked, IntegrityConfig};
use crate::security::sanitize_torrent_relative_path;

#[derive(Debug, Clone)]
pub struct PeerEndpointStore {
    root: PathBuf,
    relative: PathBuf,
    /// Shared across clones — file mutations must serialize on one lock.
    lock: Arc<Mutex<()>>,
    integrity: Option<IntegrityConfig>,
}

impl PeerEndpointStore {
    /// Split `path` into parent root + file name and jail I/O under that root.
    pub fn new(path: impl Into<PathBuf>) -> Self {
        let path = path.into();
        let relative = path
            .file_name()
            .map(PathBuf::from)
            .unwrap_or_else(|| PathBuf::from("peers.kdl"));
        let root = path
            .parent()
            .map(Path::to_path_buf)
            .unwrap_or_else(|| PathBuf::from("."));
        Self {
            root,
            relative,
            lock: Arc::new(Mutex::new(())),
            integrity: None,
        }
    }

    /// Explicit jail: store `relative` under `root`.
    pub fn under_root(root: impl Into<PathBuf>, relative: impl AsRef<Path>) -> Result<Self> {
        let relative = sanitize_torrent_relative_path(relative.as_ref())?;
        Ok(Self {
            root: root.into(),
            relative,
            lock: Arc::new(Mutex::new(())),
            integrity: None,
        })
    }

    pub fn with_integrity(mut self, integrity: IntegrityConfig) -> Self {
        self.integrity = Some(integrity);
        self
    }

    pub fn path(&self) -> PathBuf {
        self.root.join(&self.relative)
    }

    pub fn root(&self) -> &Path {
        &self.root
    }

    pub fn relative(&self) -> &Path {
        &self.relative
    }

    pub fn load(&self) -> Result<Vec<SocketAddr>> {
        let _guard = self.lock.lock().expect("peer store lock");
        self.load_unlocked()
    }

    fn load_unlocked(&self) -> Result<Vec<SocketAddr>> {
        let data = match crate::security::read_bytes_under_root(&self.root, &self.relative) {
            Ok(data) => data,
            Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {
                return Ok(Vec::new());
            }
            Err(err) => {
                return Err(Error::Secure(format!(
                    "read peer store {}: {err}",
                    self.path().display()
                )));
            }
        };
        let plain = self.open_payload(&data)?;
        let text = std::str::from_utf8(&plain)
            .map_err(|err| Error::Secure(format!("peer store utf-8: {err}")))?;
        let doc = text
            .parse::<KdlDocument>()
            .map_err(|err| Error::Secure(format!("parse peer store: {err}")))?;
        let Some(children) = doc.get("peers").and_then(|n| n.children()) else {
            return Ok(Vec::new());
        };
        let mut out = Vec::new();
        for node in children.nodes() {
            if node.name().value() != "peer" {
                continue;
            }
            if let Some(addr) = node
                .entries()
                .first()
                .and_then(|e| e.value().as_string())
                .and_then(|s| s.parse().ok())
            {
                out.push(addr);
            }
        }
        Ok(out)
    }

    pub fn save(&self, peers: &[SocketAddr]) -> Result<()> {
        let _guard = self.lock.lock().expect("peer store lock");
        self.save_unlocked(peers)
    }

    fn save_unlocked(&self, peers: &[SocketAddr]) -> Result<()> {
        let mut children = KdlDocument::new();
        for addr in peers {
            let mut node = KdlNode::new("peer");
            node.push(addr.to_string());
            children.nodes_mut().push(node);
        }
        let mut root = KdlNode::new("peers");
        root.set_children(children);
        let mut doc = KdlDocument::new();
        doc.nodes_mut().push(root);
        let plain = doc.to_string();
        let stored = self.seal_payload(plain.as_bytes())?;
        crate::security::write_bytes_under_root(&self.root, &self.relative, &stored).map_err(
            |err| Error::Secure(format!("persist peer store {}: {err}", self.path().display())),
        )
    }

    fn seal_payload(&self, plain: &[u8]) -> Result<Vec<u8>> {
        if let Some(cfg) = &self.integrity {
            let context = format!("peers:{}", self.relative.display());
            seal_tracked(cfg, plain, &context)
        } else {
            Ok(plain.to_vec())
        }
    }

    fn open_payload(&self, stored: &[u8]) -> Result<Vec<u8>> {
        if let Some(cfg) = &self.integrity {
            let context = format!("peers:{}", self.relative.display());
            // Fail closed: never accept unauthenticated cleartext when sealing is configured.
            open_tracked(cfg, stored, &context)
        } else {
            Ok(stored.to_vec())
        }
    }

    pub fn remember(&self, addr: SocketAddr) -> Result<()> {
        let _guard = self.lock.lock().expect("peer store lock");
        let mut peers = self.load_unlocked()?;
        peers.retain(|p| *p != addr);
        peers.insert(0, addr);
        peers.truncate(32);
        self.save_unlocked(&peers)
    }

    pub fn forget(&self, addr: SocketAddr) -> Result<()> {
        let _guard = self.lock.lock().expect("peer store lock");
        let mut peers = self.load_unlocked()?;
        peers.retain(|p| *p != addr);
        self.save_unlocked(&peers)
    }
}

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

    #[test]
    fn roundtrip_peer_store() {
        let dir = tempfile::tempdir().unwrap();
        let store = PeerEndpointStore::new(dir.path().join("peers.kdl"));
        let addr: SocketAddr = "127.0.0.1:7000".parse().unwrap();
        store.remember(addr).unwrap();
        let loaded = store.load().unwrap();
        assert_eq!(loaded, vec![addr]);
    }

    #[test]
    fn clones_share_lock_and_state() {
        let dir = tempfile::tempdir().unwrap();
        let store = PeerEndpointStore::new(dir.path().join("peers.kdl"));
        let clone = store.clone();
        let a: SocketAddr = "127.0.0.1:7000".parse().unwrap();
        let b: SocketAddr = "127.0.0.1:7001".parse().unwrap();
        store.remember(a).unwrap();
        clone.remember(b).unwrap();
        let loaded = store.load().unwrap();
        assert_eq!(loaded.len(), 2);
        assert_eq!(clone.load().unwrap(), loaded);
        // Same Arc mutex identity.
        assert!(Arc::ptr_eq(&store.lock, &clone.lock));
    }

    #[test]
    fn sealed_peer_store_roundtrip() {
        let dir = tempfile::tempdir().unwrap();
        let integrity = IntegrityConfig {
            verify_blocks: true,
            ecc_enabled: false,
            ecc_data_shards: 4,
            ecc_parity_shards: 1,
            encrypt_sidecars: true,
            cipher: crate::integrity::CipherConfig::from_key([5u8; 32]),
        };
        let store = PeerEndpointStore::under_root(dir.path(), Path::new(".torrentdht/peers.kdl"))
            .unwrap()
            .with_integrity(integrity);
        let addr: SocketAddr = "127.0.0.1:7001".parse().unwrap();
        store.remember(addr).unwrap();
        let loaded = store.load().unwrap();
        assert_eq!(loaded, vec![addr]);
    }
}