torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Dual-stack listen helpers, rate limiting, dial policy, and correlation.

pub mod correlation;
pub mod dial;
pub mod random;
pub mod rate;
pub mod udp_rate;

pub use correlation::{CorrelationKey, PendingMap, TxId};
pub use dial::DialGate;
pub use random::{fill_random, random_bytes};
pub use rate::RateLimiter;
pub use udp_rate::{ReplyBudget, UdpRateLimit};

use std::net::{IpAddr, Ipv6Addr, SocketAddr, TcpListener as StdTcpListener, UdpSocket as StdUdpSocket};

use socket2::{Domain, Protocol, Socket, Type};
use tokio::io::AsyncReadExt;
use tokio::net::{TcpListener, TcpStream, UdpSocket};

use crate::error::{Error, Result};

/// Connect to a previously resolved (and dial-gated) address, then verify the
/// peer IP still matches. Prevents a second DNS lookup / rebinding between
/// resolve and connect when callers hold a `SocketAddr`.
pub async fn connect_pinned(addr: SocketAddr) -> Result<TcpStream> {
    let stream = TcpStream::connect(addr).await?;
    let peer = stream.peer_addr().map_err(Error::from)?;
    if peer.ip() != addr.ip() {
        return Err(Error::Session(format!(
            "connect peer IP {} != resolved {}",
            peer.ip(),
            addr.ip()
        )));
    }
    Ok(stream)
}

/// Read until EOF, refusing to buffer more than `max` bytes.
pub async fn read_capped<R: AsyncReadExt + Unpin>(reader: &mut R, max: usize) -> Result<Vec<u8>> {
    let mut buf = Vec::new();
    let mut chunk = [0u8; 8192];
    loop {
        let n = reader.read(&mut chunk).await?;
        if n == 0 {
            break;
        }
        if buf.len().saturating_add(n) > max {
            return Err(Error::Session(format!(
                "response exceeds size limit ({max} bytes)"
            )));
        }
        buf.extend_from_slice(&chunk[..n]);
    }
    Ok(buf)
}

pub async fn bind_tcp(port: u16, dual_stack: bool) -> Result<TcpListener> {
    if dual_stack {
        #[cfg(not(unix))]
        {
            return Err(Error::Config(
                "listen-dual-stack #true requires Unix; set listen-dual-stack #false for IPv4-only"
                    .into(),
            ));
        }
        #[cfg(unix)]
        {
            match bind_tcp_v6_dualstack(port) {
                Ok(listener) => return Ok(listener),
                Err(err) => {
                    tracing::warn!(
                        %err,
                        port,
                        "listen-dual-stack TCP bind failed; falling back to IPv4-only"
                    );
                }
            }
        }
    }
    let addr = SocketAddr::from(([0, 0, 0, 0], port));
    TcpListener::bind(addr)
        .await
        .map_err(Error::from)
}

pub async fn bind_udp(port: u16, dual_stack: bool) -> Result<UdpSocket> {
    if dual_stack {
        #[cfg(not(unix))]
        {
            return Err(Error::Config(
                "listen-dual-stack #true requires Unix; set listen-dual-stack #false for IPv4-only"
                    .into(),
            ));
        }
        #[cfg(unix)]
        {
            match bind_udp_v6_dualstack(port) {
                Ok(socket) => return Ok(socket),
                Err(err) => {
                    tracing::warn!(
                        %err,
                        port,
                        "listen-dual-stack UDP bind failed; falling back to IPv4-only"
                    );
                }
            }
        }
    }
    let addr = SocketAddr::from(([0, 0, 0, 0], port));
    UdpSocket::bind(addr)
        .await
        .map_err(Error::from)
}

fn bind_tcp_v6_dualstack(port: u16) -> Result<TcpListener> {
    let socket = Socket::new(Domain::IPV6, Type::STREAM, Some(Protocol::TCP))?;
    socket.set_only_v6(false)?;
    socket.set_reuse_address(true)?;
    #[cfg(unix)]
    {
        use std::os::unix::io::{FromRawFd, IntoRawFd};
        let addr = SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port);
        socket.bind(&addr.into())?;
        socket.listen(128)?;
        let std = unsafe { StdTcpListener::from_raw_fd(socket.into_raw_fd()) };
        std.set_nonblocking(true)?;
        Ok(TcpListener::from_std(std)?)
    }
    #[cfg(not(unix))]
    {
        let _ = port;
        Err(Error::Config("dual-stack TCP requires unix".into()))
    }
}

fn bind_udp_v6_dualstack(port: u16) -> Result<UdpSocket> {
    let socket = Socket::new(Domain::IPV6, Type::DGRAM, Some(Protocol::UDP))?;
    socket.set_only_v6(false)?;
    socket.set_reuse_address(true)?;
    #[cfg(unix)]
    {
        use std::os::unix::io::{FromRawFd, IntoRawFd};
        let addr = SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port);
        socket.bind(&addr.into())?;
        let std = unsafe { StdUdpSocket::from_raw_fd(socket.into_raw_fd()) };
        std.set_nonblocking(true)?;
        Ok(UdpSocket::from_std(std)?)
    }
    #[cfg(not(unix))]
    {
        let _ = port;
        Err(Error::Config("dual-stack UDP requires unix".into()))
    }
}

/// Collapse IPv4-mapped IPv6 (`:ffff:x.x.x.x`) to IPv4 so dual-stack UDP
/// sockets correlate pending replies with the address used in `send_to`.
pub fn normalize_socket_addr(addr: SocketAddr) -> SocketAddr {
    match addr {
        SocketAddr::V6(v6) => {
            if let Some(v4) = v6.ip().to_ipv4_mapped() {
                SocketAddr::new(IpAddr::V4(v4), v6.port())
            } else {
                addr
            }
        }
        other => other,
    }
}

/// Best-effort routable IPv6 via UDP connect trick (no traffic sent).
pub fn detect_local_ipv6() -> Option<Ipv6Addr> {
    let socket = StdUdpSocket::bind("[::]:0").ok()?;
    socket.connect("[2001:4860:4860::8888]:80").ok()?;
    match socket.local_addr().ok()? {
        SocketAddr::V6(addr) if !addr.ip().is_loopback() && !addr.ip().is_unspecified() => {
            Some(*addr.ip())
        }
        _ => None,
    }
}

pub fn compact_ipv6(addr: Ipv6Addr, port: u16) -> [u8; 18] {
    let mut out = [0u8; 18];
    out[..16].copy_from_slice(&addr.octets());
    out[16..].copy_from_slice(&port.to_be_bytes());
    out
}

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

    #[test]
    fn compact_ipv6_roundtrip() {
        let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
        let bytes = compact_ipv6(ip, 6881);
        let mut ip_bytes = [0u8; 16];
        ip_bytes.copy_from_slice(&bytes[..16]);
        let port = u16::from_be_bytes([bytes[16], bytes[17]]);
        assert_eq!(IpAddr::from(ip_bytes), IpAddr::from(ip));
        assert_eq!(port, 6881);
    }

    #[test]
    fn normalize_maps_ipv4_mapped() {
        let mapped: SocketAddr = "[::ffff:203.0.113.9]:6881".parse().unwrap();
        let v4: SocketAddr = "203.0.113.9:6881".parse().unwrap();
        assert_eq!(normalize_socket_addr(mapped), v4);
        assert_eq!(normalize_socket_addr(v4), v4);
    }
}