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,
lock: Arc<Mutex<()>>,
integrity: Option<IntegrityConfig>,
}
impl PeerEndpointStore {
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,
}
}
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());
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);
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]);
}
}