torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Swarm stack selection: security layer × transport.
//!
//! Default: **mTLS + TCP**. Also supported: **MSE + TCP**, **MSE + uTP**.
//! mTLS + uTP is rejected (TLS stack is TCP-only).

use crate::config::{Config, SwarmSecurity, SwarmTransport};
use crate::error::{Error, Result};

/// Resolved swarm stack from host config.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SwarmStack {
    pub security: SwarmSecurity,
    pub transport: SwarmTransport,
}

impl SwarmStack {
    pub fn from_config(cfg: &Config) -> Self {
        Self {
            security: cfg.swarm_security,
            transport: cfg.swarm_transport,
        }
    }

    pub fn is_implemented(self) -> bool {
        match (self.security, self.transport) {
            (SwarmSecurity::Mtls, SwarmTransport::Tcp) => true,
            (SwarmSecurity::Mse, SwarmTransport::Tcp) => true,
            (SwarmSecurity::Mse, SwarmTransport::Utp) => crate::utp::IMPLEMENTED,
            (SwarmSecurity::Mtls, SwarmTransport::Utp) => false,
        }
    }

    pub fn describe(self) -> String {
        format!("{}+{}", self.security.as_str(), self.transport.as_str())
    }

    /// Route table for dial/accept: which backend owns this stack.
    pub fn backend(self) -> SwarmBackend {
        match (self.security, self.transport) {
            (SwarmSecurity::Mtls, SwarmTransport::Tcp) => SwarmBackend::MtlsTcp,
            (SwarmSecurity::Mse, SwarmTransport::Tcp) => SwarmBackend::MseTcp,
            (SwarmSecurity::Mse, SwarmTransport::Utp) => SwarmBackend::MseUtp,
            (SwarmSecurity::Mtls, SwarmTransport::Utp) => SwarmBackend::Invalid,
        }
    }
}

/// Implementation backend selected by [`SwarmStack`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SwarmBackend {
    /// mTLS handoff then BitTorrent on TLS/TCP.
    MtlsTcp,
    /// MSE/PE then BitTorrent on TCP.
    MseTcp,
    /// uTP then MSE/PE then BitTorrent.
    MseUtp,
    /// Rejected combination (e.g. mTLS + uTP).
    Invalid,
}

/// Fail closed for unsupported or unfinished stacks.
pub fn validate_swarm_stack(cfg: &Config) -> Result<()> {
    let stack = SwarmStack::from_config(cfg);
    if matches!(
        (stack.security, stack.transport),
        (SwarmSecurity::Mtls, SwarmTransport::Utp)
    ) {
        return Err(Error::Config(
            "swarm-security \"mtls\" requires swarm-transport \"tcp\" (TLS is TCP-only; use mse+utp)"
                .into(),
        ));
    }
    if stack.is_implemented() {
        return Ok(());
    }
    Err(Error::Config(format!(
        "swarm stack {} is not implemented",
        stack.describe()
    )))
}

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

    #[test]
    fn default_stack_is_mtls_tcp() {
        let cfg = Config::default();
        let stack = SwarmStack::from_config(&cfg);
        assert_eq!(stack.backend(), SwarmBackend::MtlsTcp);
        validate_swarm_stack(&cfg).expect("default ok");
    }

    #[test]
    fn mse_tcp_is_allowed() {
        let cfg = Config::default().with_swarm_security(SwarmSecurity::Mse);
        assert_eq!(SwarmStack::from_config(&cfg).backend(), SwarmBackend::MseTcp);
        validate_swarm_stack(&cfg).expect("mse+tcp");
    }

    #[test]
    fn mse_utp_is_allowed() {
        let cfg = Config::default()
            .with_swarm_security(SwarmSecurity::Mse)
            .with_swarm_transport(SwarmTransport::Utp);
        assert_eq!(SwarmStack::from_config(&cfg).backend(), SwarmBackend::MseUtp);
        validate_swarm_stack(&cfg).expect("mse+utp");
    }

    #[test]
    fn mtls_utp_rejected() {
        let cfg = Config::default().with_swarm_transport(SwarmTransport::Utp);
        let err = validate_swarm_stack(&cfg).expect_err("mtls+utp");
        assert!(err.to_string().contains("TCP-only") || err.to_string().contains("mtls"));
    }
}