use std::path::PathBuf;
use kdl::KdlDocument;
use zeroize::Zeroizing;
use crate::error::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PeerDiscoveryMode {
Hybrid,
Tracker,
Dht,
}
impl PeerDiscoveryMode {
pub fn parse(raw: &str) -> Result<Self> {
match raw {
"hybrid" => Ok(Self::Hybrid),
"tracker" | "tracker-only" => Ok(Self::Tracker),
"dht" | "dht-only" => Ok(Self::Dht),
other => Err(Error::Config(format!(
"peer-discovery must be hybrid, tracker, or dht (got {other})"
))),
}
}
pub fn uses_tracker(self) -> bool {
matches!(self, Self::Hybrid | Self::Tracker)
}
pub fn uses_dht(self) -> bool {
matches!(self, Self::Hybrid | Self::Dht)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SwarmSecurity {
#[default]
Mtls,
Mse,
}
impl SwarmSecurity {
pub fn parse(raw: &str) -> Result<Self> {
match raw {
"mtls" | "tls" => Ok(Self::Mtls),
"mse" | "mse-pe" | "pe" => Ok(Self::Mse),
other => Err(Error::Config(format!(
"swarm-security must be mtls or mse (got {other})"
))),
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::Mtls => "mtls",
Self::Mse => "mse",
}
}
pub fn is_implemented(self) -> bool {
match self {
Self::Mtls | Self::Mse => true,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SwarmTransport {
#[default]
Tcp,
Utp,
}
impl SwarmTransport {
pub fn parse(raw: &str) -> Result<Self> {
match raw {
"tcp" => Ok(Self::Tcp),
"utp" | "uTP" => Ok(Self::Utp),
other => Err(Error::Config(format!(
"swarm-transport must be tcp or utp (got {other})"
))),
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::Tcp => "tcp",
Self::Utp => "utp",
}
}
pub fn is_implemented(self) -> bool {
matches!(self, Self::Tcp | Self::Utp)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BootstrapNode {
pub host: String,
pub port: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ResilienceConfig {
pub heal_interval_secs: u64,
pub stale_peer_secs: u64,
pub stalled_download_secs: u64,
pub peer_ban_secs: u64,
pub checkpoint_interval_secs: u64,
pub max_peer_failures: u32,
pub run_retry_initial_secs: u64,
pub run_retry_max_secs: u64,
}
impl Default for ResilienceConfig {
fn default() -> Self {
Self {
heal_interval_secs: 15,
stale_peer_secs: 45,
stalled_download_secs: 120,
peer_ban_secs: 300,
checkpoint_interval_secs: 30,
max_peer_failures: 5,
run_retry_initial_secs: 3,
run_retry_max_secs: 60,
}
}
}
impl ResilienceConfig {
pub fn heal_interval(&self) -> std::time::Duration {
std::time::Duration::from_secs(self.heal_interval_secs.max(1))
}
pub fn checkpoint_interval(&self) -> std::time::Duration {
std::time::Duration::from_secs(self.checkpoint_interval_secs.max(1))
}
}
#[derive(Debug, Clone)]
pub struct Config {
pub listen_port: u16,
pub download_dir: PathBuf,
pub state_dir: Option<PathBuf>,
pub dht_enabled: bool,
pub peer_discovery: PeerDiscoveryMode,
pub max_peers: usize,
pub block_size: u32,
pub memory_cache_mb: usize,
pub flush_workers: usize,
pub flush_batch_size: usize,
pub integrity_verify_blocks: bool,
pub integrity_ecc_enabled: bool,
pub integrity_ecc_data_shards: usize,
pub integrity_ecc_parity_shards: usize,
pub integrity_encrypt_sidecars: bool,
pub integrity_key_file: Option<PathBuf>,
pub integrity_passphrase: Option<Zeroizing<String>>,
pub integrity_access_secret: Option<Zeroizing<Vec<u8>>>,
pub integrity_sign_torrents: bool,
pub integrity_signing_key_file: Option<PathBuf>,
pub integrity_create_image: bool,
pub integrity_require_signed_torrents: bool,
pub integrity_trusted_signing_keys: Vec<[u8; 32]>,
pub tracker_block_private: bool,
pub max_upload_slots: usize,
pub upload_rotate_secs: u64,
pub nat_enabled: bool,
pub nat_map_tcp: bool,
pub nat_map_udp: bool,
pub nat_upnp: bool,
pub nat_natpmp: bool,
pub utp_enabled: bool,
pub swarm_security: SwarmSecurity,
pub swarm_transport: SwarmTransport,
pub end_game_threshold: u32,
pub pex_enabled: bool,
pub super_seed_enabled: bool,
pub web_seed_enabled: bool,
pub web_seed_ftp_enabled: bool,
pub seed_require_verified: bool,
pub listen_dual_stack: bool,
pub announce_ip: Option<std::net::Ipv4Addr>,
pub announce_ipv6: Option<std::net::Ipv6Addr>,
pub download_rate_kbps: u64,
pub upload_rate_kbps: u64,
pub dht_persist: bool,
pub dht_bootstrap: Vec<BootstrapNode>,
pub dht_peer_announce_ttl_secs: u64,
pub rpc_enabled: bool,
pub rpc_listen: Option<String>,
pub rpc_auth_token: Option<Zeroizing<String>>,
pub rpc_allow_non_loopback: bool,
pub rpc_torrent_root: Option<PathBuf>,
pub download_files: Vec<String>,
pub resilience: ResilienceConfig,
pub secure_connect_timeout_secs: u64,
pub secure_tls_timeout_secs: u64,
pub secure_handshake_timeout_secs: u64,
}
impl Default for Config {
fn default() -> Self {
Self {
listen_port: 6881,
download_dir: PathBuf::from("./downloads"),
state_dir: None,
dht_enabled: true,
peer_discovery: PeerDiscoveryMode::Hybrid,
max_peers: 55,
block_size: 16 * 1024,
memory_cache_mb: 256,
flush_workers: 2,
flush_batch_size: 32,
integrity_verify_blocks: true,
integrity_ecc_enabled: true,
integrity_ecc_data_shards: 4,
integrity_ecc_parity_shards: 1,
integrity_encrypt_sidecars: true,
integrity_key_file: None,
integrity_passphrase: None,
integrity_access_secret: None,
integrity_sign_torrents: false,
integrity_signing_key_file: None,
integrity_create_image: true,
integrity_require_signed_torrents: false,
integrity_trusted_signing_keys: Vec::new(),
tracker_block_private: true,
max_upload_slots: 8,
upload_rotate_secs: 30,
nat_enabled: false,
nat_map_tcp: true,
nat_map_udp: true,
nat_upnp: true,
nat_natpmp: true,
utp_enabled: false,
swarm_security: SwarmSecurity::Mtls,
swarm_transport: SwarmTransport::Tcp,
end_game_threshold: 4,
pex_enabled: false,
super_seed_enabled: false,
web_seed_enabled: false,
web_seed_ftp_enabled: false,
seed_require_verified: true,
listen_dual_stack: true,
announce_ip: None,
announce_ipv6: None,
download_rate_kbps: 0,
upload_rate_kbps: 0,
dht_persist: true,
dht_bootstrap: Vec::new(),
dht_peer_announce_ttl_secs: 1800,
rpc_enabled: false,
rpc_listen: None,
rpc_auth_token: None,
rpc_allow_non_loopback: false,
rpc_torrent_root: None,
download_files: Vec::new(),
resilience: ResilienceConfig::default(),
secure_connect_timeout_secs: 5,
secure_tls_timeout_secs: 10,
secure_handshake_timeout_secs: 15,
}
}
}
impl Config {
pub fn for_commercial_host(download_dir: impl Into<PathBuf>, listen_port: u16) -> Self {
Self {
listen_port,
download_dir: download_dir.into(),
dht_enabled: true,
peer_discovery: PeerDiscoveryMode::Hybrid,
nat_enabled: false,
utp_enabled: false,
swarm_security: SwarmSecurity::Mtls,
swarm_transport: SwarmTransport::Tcp,
pex_enabled: false,
super_seed_enabled: false,
web_seed_enabled: false,
web_seed_ftp_enabled: false,
seed_require_verified: true,
rpc_enabled: false,
rpc_listen: None,
rpc_auth_token: None,
rpc_allow_non_loopback: false,
rpc_torrent_root: None,
integrity_encrypt_sidecars: true,
integrity_require_signed_torrents: true,
tracker_block_private: true,
..Self::default()
}
}
pub fn with_trusted_signing_keys(mut self, keys: Vec<[u8; 32]>) -> Self {
self.integrity_trusted_signing_keys = keys;
self
}
pub fn with_download_dir(mut self, dir: impl Into<PathBuf>) -> Self {
self.download_dir = dir.into();
self
}
pub fn with_state_dir(mut self, dir: impl Into<PathBuf>) -> Self {
self.state_dir = Some(dir.into());
self
}
pub fn with_swarm_security(mut self, security: SwarmSecurity) -> Self {
self.swarm_security = security;
self
}
pub fn with_swarm_transport(mut self, transport: SwarmTransport) -> Self {
self.swarm_transport = transport;
self.utp_enabled = matches!(transport, SwarmTransport::Utp);
self
}
pub fn with_loopback_rpc(mut self, listen: impl Into<String>, auth_token: impl Into<String>) -> Self {
self.rpc_enabled = true;
self.rpc_listen = Some(listen.into());
self.rpc_auth_token = Some(Zeroizing::new(auth_token.into()));
self.rpc_allow_non_loopback = false;
self
}
pub fn from_kdl_str(input: &str) -> Result<Self> {
let doc = input
.parse::<KdlDocument>()
.map_err(|err| Error::Config(err.to_string()))?;
let mut cfg = Self::default();
if let Some(port) = node_arg_integer(&doc, "listen-port") {
cfg.listen_port = u16_from_kdl(port, "listen-port")?;
}
if let Some(dir) = node_arg_string(&doc, "download-dir") {
cfg.download_dir = PathBuf::from(dir);
}
if let Some(dir) = node_arg_string(&doc, "state-dir") {
cfg.state_dir = Some(PathBuf::from(dir));
}
if let Some(enabled) = node_arg_bool(&doc, "dht-enabled") {
cfg.dht_enabled = enabled;
}
if let Some(mode) = node_arg_string(&doc, "peer-discovery") {
cfg.peer_discovery = PeerDiscoveryMode::parse(&mode)?;
}
let mut utp_flag: Option<bool> = None;
let mut transport_explicit: Option<SwarmTransport> = None;
if let Some(mode) = node_arg_string(&doc, "swarm-security") {
cfg.swarm_security = SwarmSecurity::parse(&mode)?;
}
if let Some(mode) = node_arg_string(&doc, "swarm-transport") {
transport_explicit = Some(SwarmTransport::parse(&mode)?);
}
if let Some(max_peers) = node_arg_integer(&doc, "max-peers") {
cfg.max_peers = max_peers as usize;
}
if let Some(block_size) = node_arg_integer(&doc, "block-size") {
cfg.block_size = u32_from_kdl(block_size, "block-size")?;
}
if let Some(cache) = node_arg_integer(&doc, "memory-cache-mb") {
cfg.memory_cache_mb = cache as usize;
}
if let Some(workers) = node_arg_integer(&doc, "flush-workers") {
cfg.flush_workers = workers as usize;
}
if let Some(batch) = node_arg_integer(&doc, "flush-batch-size") {
cfg.flush_batch_size = batch as usize;
}
if let Some(integrity) = doc.get("integrity").and_then(|node| node.children()) {
if let Some(value) = child_bool(integrity, "verify-blocks") {
cfg.integrity_verify_blocks = value;
}
if let Some(value) = child_bool(integrity, "ecc") {
cfg.integrity_ecc_enabled = value;
}
if let Some(value) = child_integer(integrity, "ecc-data-shards") {
cfg.integrity_ecc_data_shards = value as usize;
}
if let Some(value) = child_integer(integrity, "ecc-parity-shards") {
cfg.integrity_ecc_parity_shards = value as usize;
}
if let Some(value) = child_bool(integrity, "encrypt-sidecars") {
cfg.integrity_encrypt_sidecars = value;
}
if let Some(value) = child_string(integrity, "encryption-key-file") {
cfg.integrity_key_file = Some(PathBuf::from(value));
}
if let Some(value) = child_string(integrity, "passphrase") {
cfg.integrity_passphrase = Some(Zeroizing::new(value));
}
if let Some(value) = child_bool(integrity, "sign-torrents") {
cfg.integrity_sign_torrents = value;
}
if let Some(value) = child_string(integrity, "signing-key-file") {
cfg.integrity_signing_key_file = Some(PathBuf::from(value));
}
if let Some(value) = child_bool(integrity, "create-image") {
cfg.integrity_create_image = value;
}
if let Some(value) = child_bool(integrity, "require-signed-torrents") {
cfg.integrity_require_signed_torrents = value;
}
cfg.integrity_trusted_signing_keys =
parse_trusted_signing_keys(integrity)?;
}
if let Some(slots) = node_arg_integer(&doc, "max-upload-slots") {
cfg.max_upload_slots = slots.max(1) as usize;
}
if let Some(secs) = node_arg_integer(&doc, "upload-rotate-secs") {
cfg.upload_rotate_secs = secs.max(0) as u64;
}
if let Some(enabled) = node_arg_bool(&doc, "nat-enabled") {
cfg.nat_enabled = enabled;
}
if let Some(enabled) = node_arg_bool(&doc, "utp-enabled") {
utp_flag = Some(enabled);
}
if let Some(threshold) = node_arg_integer(&doc, "end-game-threshold") {
cfg.end_game_threshold = threshold.max(0) as u32;
}
if let Some(enabled) = node_arg_bool(&doc, "pex-enabled") {
cfg.pex_enabled = enabled;
}
if let Some(enabled) = node_arg_bool(&doc, "super-seed-enabled") {
cfg.super_seed_enabled = enabled;
}
if let Some(enabled) = node_arg_bool(&doc, "web-seed-enabled") {
cfg.web_seed_enabled = enabled;
}
if let Some(enabled) = node_arg_bool(&doc, "web-seed-ftp-enabled") {
cfg.web_seed_ftp_enabled = enabled;
}
if let Some(enabled) = node_arg_bool(&doc, "seed-require-verified") {
cfg.seed_require_verified = enabled;
}
if let Some(enabled) = node_arg_bool(&doc, "listen-dual-stack") {
cfg.listen_dual_stack = enabled;
}
if let Some(ip) = node_arg_string(&doc, "announce-ip") {
cfg.announce_ip = Some(
ip.parse()
.map_err(|_| Error::Config(format!("invalid announce-ip: {ip}")))?,
);
}
if let Some(ip) = node_arg_string(&doc, "announce-ipv6") {
cfg.announce_ipv6 = Some(
ip.parse()
.map_err(|_| Error::Config(format!("invalid announce-ipv6: {ip}")))?,
);
}
if let Some(rate) = node_arg_integer(&doc, "download-rate-kbps") {
cfg.download_rate_kbps = rate.max(0) as u64;
}
if let Some(rate) = node_arg_integer(&doc, "upload-rate-kbps") {
cfg.upload_rate_kbps = rate.max(0) as u64;
}
if let Some(enabled) = node_arg_bool(&doc, "dht-persist") {
cfg.dht_persist = enabled;
}
if let Some(ttl) = node_arg_integer(&doc, "dht-peer-announce-ttl-secs") {
cfg.dht_peer_announce_ttl_secs = ttl.max(60) as u64;
}
if let Some(bootstrap) = doc.get("dht-bootstrap").and_then(|node| node.children()) {
cfg.dht_bootstrap.clear();
for entry in bootstrap.nodes() {
if entry.name().value() != "node" {
continue;
}
let host = entry
.entries()
.first()
.and_then(|e| e.value().as_string())
.ok_or_else(|| Error::Config("dht-bootstrap node missing host".into()))?;
let port = entry
.entries()
.get(1)
.and_then(|e| e.value().as_integer())
.ok_or_else(|| {
Error::Config("dht-bootstrap node missing port integer".into())
})?;
cfg.dht_bootstrap.push(BootstrapNode {
host: host.to_string(),
port: u16_from_kdl(port, "dht-bootstrap node port")?,
});
}
}
if let Some(enabled) = node_arg_bool(&doc, "rpc-enabled") {
cfg.rpc_enabled = enabled;
}
if let Some(addr) = node_arg_string(&doc, "rpc-listen") {
cfg.rpc_listen = Some(addr);
}
if let Some(token) = node_arg_string(&doc, "rpc-auth-token") {
cfg.rpc_auth_token = Some(Zeroizing::new(token));
}
if let Some(enabled) = node_arg_bool(&doc, "rpc-allow-non-loopback") {
cfg.rpc_allow_non_loopback = enabled;
}
if let Some(path) = node_arg_string(&doc, "rpc-torrent-root") {
cfg.rpc_torrent_root = Some(PathBuf::from(path));
}
if let Some(files) = doc.get("download-files").and_then(|node| node.children()) {
cfg.download_files.clear();
for entry in files.nodes() {
if entry.name().value() != "file" {
continue;
}
if let Some(path) = entry.entries().first().and_then(|e| e.value().as_string()) {
cfg.download_files.push(path.to_string());
}
}
}
if let Some(nat) = doc.get("nat").and_then(|node| node.children()) {
if let Some(value) = child_bool(nat, "map-tcp") {
cfg.nat_map_tcp = value;
}
if let Some(value) = child_bool(nat, "map-udp") {
cfg.nat_map_udp = value;
}
if let Some(value) = child_bool(nat, "upnp") {
cfg.nat_upnp = value;
}
if let Some(value) = child_bool(nat, "natpmp") {
cfg.nat_natpmp = value;
}
}
if let Some(value) = node_arg_bool(&doc, "tracker-block-private") {
cfg.tracker_block_private = value;
}
if let Some(secure) = doc.get("secure").and_then(|node| node.children()) {
if let Some(value) = child_integer(secure, "connect-timeout-secs") {
cfg.secure_connect_timeout_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(secure, "tls-timeout-secs") {
cfg.secure_tls_timeout_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(secure, "handshake-timeout-secs") {
cfg.secure_handshake_timeout_secs = value.max(1) as u64;
}
}
if let Some(value) = node_arg_integer(&doc, "secure-connect-timeout-secs") {
cfg.secure_connect_timeout_secs = value.max(1) as u64;
}
if let Some(value) = node_arg_integer(&doc, "secure-tls-timeout-secs") {
cfg.secure_tls_timeout_secs = value.max(1) as u64;
}
if let Some(value) = node_arg_integer(&doc, "secure-handshake-timeout-secs") {
cfg.secure_handshake_timeout_secs = value.max(1) as u64;
}
if let Some(resilience) = doc.get("resilience").and_then(|node| node.children()) {
if let Some(value) = child_integer(resilience, "heal-interval-secs") {
cfg.resilience.heal_interval_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(resilience, "stale-peer-secs") {
cfg.resilience.stale_peer_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(resilience, "stalled-download-secs") {
cfg.resilience.stalled_download_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(resilience, "peer-ban-secs") {
cfg.resilience.peer_ban_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(resilience, "checkpoint-interval-secs") {
cfg.resilience.checkpoint_interval_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(resilience, "max-peer-failures") {
cfg.resilience.max_peer_failures = value.max(1) as u32;
}
if let Some(value) = child_integer(resilience, "run-retry-initial-secs") {
cfg.resilience.run_retry_initial_secs = value.max(1) as u64;
}
if let Some(value) = child_integer(resilience, "run-retry-max-secs") {
cfg.resilience.run_retry_max_secs = value.max(1) as u64;
}
}
crate::rpc::validate_rpc_config(&cfg)?;
crate::torrent::validate_signed_torrent_config(&cfg)?;
reconcile_swarm_transport(&mut cfg, utp_flag, transport_explicit)?;
crate::swarm::validate_swarm_stack(&cfg)?;
Ok(cfg)
}
pub fn from_kdl_file(path: impl AsRef<std::path::Path>) -> Result<Self> {
let data = std::fs::read_to_string(path)?;
Self::from_kdl_str(&data)
}
pub fn memory_cache_bytes(&self) -> usize {
self.memory_cache_mb.saturating_mul(1024 * 1024)
}
}
fn node_arg_integer(doc: &KdlDocument, name: &str) -> Option<i128> {
doc.get(name)
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_integer())
}
fn node_arg_string(doc: &KdlDocument, name: &str) -> Option<String> {
doc.get(name)
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_string())
.map(str::to_string)
}
fn node_arg_bool(doc: &KdlDocument, name: &str) -> Option<bool> {
doc.get(name)
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_bool())
}
fn child_bool(doc: &KdlDocument, name: &str) -> Option<bool> {
doc.get(name)
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_bool())
}
fn child_integer(doc: &KdlDocument, name: &str) -> Option<i128> {
doc.get(name)
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_integer())
}
fn child_string(doc: &KdlDocument, name: &str) -> Option<String> {
doc.get(name)
.and_then(|node| node.entries().first())
.and_then(|entry| entry.value().as_string())
.map(str::to_string)
}
fn u16_from_kdl(value: i128, field: &str) -> Result<u16> {
if !(0..=u16::MAX as i128).contains(&value) {
return Err(Error::Config(format!("{field} out of range for u16")));
}
Ok(value as u16)
}
fn u32_from_kdl(value: i128, field: &str) -> Result<u32> {
if !(0..=u32::MAX as i128).contains(&value) {
return Err(Error::Config(format!("{field} out of range for u32")));
}
Ok(value as u32)
}
fn reconcile_swarm_transport(
cfg: &mut Config,
utp_flag: Option<bool>,
transport_explicit: Option<SwarmTransport>,
) -> Result<()> {
match (utp_flag, transport_explicit) {
(None, None) => {
cfg.utp_enabled = matches!(cfg.swarm_transport, SwarmTransport::Utp);
}
(Some(true), None) => {
cfg.swarm_transport = SwarmTransport::Utp;
cfg.utp_enabled = true;
}
(Some(false), None) => {
cfg.swarm_transport = SwarmTransport::Tcp;
cfg.utp_enabled = false;
}
(None, Some(transport)) => {
cfg.swarm_transport = transport;
cfg.utp_enabled = matches!(transport, SwarmTransport::Utp);
}
(Some(want_utp), Some(transport)) => {
let transport_is_utp = matches!(transport, SwarmTransport::Utp);
if want_utp != transport_is_utp {
return Err(Error::Config(format!(
"utp-enabled #{want_utp} conflicts with swarm-transport \"{}\"",
transport.as_str()
)));
}
cfg.swarm_transport = transport;
cfg.utp_enabled = want_utp;
}
}
Ok(())
}
fn parse_trusted_signing_keys(integrity: &KdlDocument) -> Result<Vec<[u8; 32]>> {
let mut keys = Vec::new();
for node in integrity.nodes() {
if node.name().value() != "trusted-signing-key" {
continue;
}
let Some(hex) = node
.entries()
.first()
.and_then(|entry| entry.value().as_string())
else {
return Err(Error::Config(
"trusted-signing-key requires a hex string argument".into(),
));
};
keys.push(parse_ed25519_pubkey_hex(hex)?);
}
Ok(keys)
}
fn parse_ed25519_pubkey_hex(hex: &str) -> Result<[u8; 32]> {
let hex = hex.trim();
if hex.len() != 64 {
return Err(Error::Config(
"trusted-signing-key must be 64 hex characters (32-byte Ed25519 key)".into(),
));
}
let mut out = [0u8; 32];
for (i, chunk) in hex.as_bytes().chunks(2).enumerate() {
let s = std::str::from_utf8(chunk).map_err(|_| {
Error::Config("trusted-signing-key hex is not valid UTF-8".into())
})?;
out[i] = u8::from_str_radix(s, 16).map_err(|_| {
Error::Config("trusted-signing-key contains non-hex characters".into())
})?;
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn loads_default_kdl() {
let cfg = Config::from_kdl_str(include_str!("../config/default.kdl"))
.unwrap_or_else(|err| {
panic!("config: {err}");
});
assert_eq!(cfg.listen_port, 6881);
assert_eq!(cfg.peer_discovery, PeerDiscoveryMode::Hybrid);
assert!(!cfg.utp_enabled);
assert!(!cfg.pex_enabled);
assert!(!cfg.web_seed_enabled);
assert!(!cfg.web_seed_ftp_enabled);
assert!(!cfg.rpc_enabled);
assert!(cfg.seed_require_verified);
assert!(cfg.dht_bootstrap.is_empty());
assert_eq!(cfg.dht_peer_announce_ttl_secs, 1800);
assert!(cfg.state_dir.is_none());
}
#[test]
fn parses_state_dir() {
let cfg = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
state-dir "./var/torrentdht"
"#,
)
.expect("config");
assert_eq!(
cfg.state_dir.as_deref(),
Some(std::path::Path::new("./var/torrentdht"))
);
}
#[test]
fn parses_dht_bootstrap_nodes() {
let cfg = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
dht-bootstrap {
node "dht.example.internal" 6881
node "192.0.2.10" 6882
}
"#,
)
.expect("config");
assert_eq!(cfg.dht_bootstrap.len(), 2);
assert_eq!(cfg.dht_bootstrap[0].host, "dht.example.internal");
assert_eq!(cfg.dht_bootstrap[0].port, 6881);
assert_eq!(cfg.dht_bootstrap[1].host, "192.0.2.10");
assert_eq!(cfg.dht_bootstrap[1].port, 6882);
}
#[test]
fn rejects_utp_with_mtls_default() {
let err = Config::from_kdl_str("utp-enabled #true\n").expect_err("utp");
assert!(
err.to_string().contains("TCP-only")
|| err.to_string().contains("mtls")
|| err.to_string().contains("not implemented")
);
}
#[test]
fn rejects_swarm_transport_utp_with_mtls() {
let err = Config::from_kdl_str("swarm-transport \"utp\"\n").expect_err("utp");
assert!(err.to_string().contains("TCP-only") || err.to_string().contains("mtls"));
}
#[test]
fn accepts_mse_with_utp() {
let cfg = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
swarm-security "mse"
swarm-transport "utp"
"#,
)
.expect("mse+utp");
assert_eq!(cfg.swarm_security, SwarmSecurity::Mse);
assert_eq!(cfg.swarm_transport, SwarmTransport::Utp);
assert!(cfg.utp_enabled);
}
#[test]
fn accepts_swarm_security_mse_with_tcp() {
let cfg = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
swarm-security "mse"
swarm-transport "tcp"
"#,
)
.expect("mse+tcp");
assert_eq!(cfg.swarm_security, SwarmSecurity::Mse);
assert_eq!(cfg.swarm_transport, SwarmTransport::Tcp);
}
#[test]
fn parses_default_swarm_stack() {
let cfg = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
swarm-security "mtls"
swarm-transport "tcp"
"#,
)
.expect("config");
assert_eq!(cfg.swarm_security, SwarmSecurity::Mtls);
assert_eq!(cfg.swarm_transport, SwarmTransport::Tcp);
assert!(!cfg.utp_enabled);
}
#[test]
fn rejects_utp_flag_transport_conflict() {
let err = Config::from_kdl_str(
r#"
utp-enabled #true
swarm-transport "tcp"
"#,
)
.expect_err("conflict");
assert!(err.to_string().contains("conflicts"));
}
#[test]
fn commercial_host_profile_is_locked_down() {
let cfg = Config::for_commercial_host("./data", 6881).with_trusted_signing_keys(vec![[9u8; 32]]);
assert!(!cfg.rpc_enabled);
assert!(!cfg.pex_enabled);
assert!(!cfg.web_seed_enabled);
assert!(!cfg.web_seed_ftp_enabled);
assert!(!cfg.nat_enabled);
assert!(cfg.seed_require_verified);
assert!(cfg.integrity_encrypt_sidecars);
assert!(cfg.integrity_require_signed_torrents);
assert!(!cfg.integrity_trusted_signing_keys.is_empty());
crate::torrent::validate_signed_torrent_config(&cfg).expect("keys present");
let with_rpc = cfg.with_loopback_rpc(
"127.0.0.1:7600",
"a-commercial-grade-rpc-token-32b",
);
assert!(with_rpc.rpc_enabled);
assert!(!with_rpc.rpc_allow_non_loopback);
}
#[test]
fn require_signed_without_keys_fails_kdl_validate() {
let err = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
integrity {
require-signed-torrents #true
}
"#,
);
assert!(err.is_err());
}
#[test]
fn parses_peer_discovery_mode() {
assert_eq!(
PeerDiscoveryMode::parse("hybrid").expect("hybrid"),
PeerDiscoveryMode::Hybrid
);
assert_eq!(
PeerDiscoveryMode::parse("dht-only").expect("dht"),
PeerDiscoveryMode::Dht
);
assert_eq!(
PeerDiscoveryMode::parse("tracker").expect("tracker"),
PeerDiscoveryMode::Tracker
);
}
#[test]
fn loads_inline_kdl() {
let cfg = Config::from_kdl_str(
r#"
listen-port 6881
download-dir "./downloads"
dht-enabled #true
max-peers 55
block-size 16384
memory-cache-mb 256
flush-workers 2
flush-batch-size 32
"#,
)
.expect("inline config");
assert_eq!(cfg.listen_port, 6881);
}
}