torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::net::SocketAddr;

/// Maximum compact peer entries accepted from one blob (DHT, tracker, etc.).
pub const MAX_COMPACT_PEERS: usize = 256;

/// Maximum compact node entries accepted from one DHT `nodes` blob.
pub const MAX_COMPACT_NODES: usize = 256;

#[derive(Debug, Clone)]
pub struct CompactNode {
    pub id: [u8; 20],
    pub addr: SocketAddr,
}

pub fn decode_peers(raw: &[u8], ipv6: bool) -> Vec<SocketAddr> {
    let stride = if ipv6 { 18 } else { 6 };
    if !raw.len().is_multiple_of(stride) {
        return Vec::new();
    }
    let cap = raw.len() / stride;
    if cap > MAX_COMPACT_PEERS {
        return Vec::new();
    }

    raw.chunks_exact(stride)
        .filter_map(|chunk| decode_compact_peer(chunk, ipv6))
        .collect()
}

pub fn peers_stride(raw: &[u8]) -> Option<usize> {
    if raw.is_empty() {
        return None;
    }
    let v4 = raw.len().is_multiple_of(6);
    let v6 = raw.len().is_multiple_of(18);
    // Prefer IPv4 when both strides divide (same rule as nodes_stride).
    match (v4, v6) {
        (true, _) => Some(6),
        (false, true) => Some(18),
        _ => None,
    }
}

pub fn decode_peers_auto(raw: &[u8]) -> Vec<SocketAddr> {
    peers_stride(raw)
        .map(|stride| decode_peers(raw, stride == 18))
        .unwrap_or_default()
}

pub fn nodes_stride(raw: &[u8]) -> Option<usize> {
    if raw.is_empty() {
        return None;
    }
    let v4 = raw.len().is_multiple_of(26);
    let v6 = raw.len().is_multiple_of(38);
    if v6 && !v4 {
        Some(38)
    } else if v4 {
        Some(26)
    } else {
        None
    }
}

pub fn decode_nodes_auto(raw: &[u8]) -> Vec<CompactNode> {
    nodes_stride(raw)
        .map(|stride| decode_nodes(raw, stride == 38))
        .unwrap_or_default()
}

pub fn decode_nodes(raw: &[u8], ipv6: bool) -> Vec<CompactNode> {
    let stride = if ipv6 { 38 } else { 26 };
    if !raw.len().is_multiple_of(stride) {
        return Vec::new();
    }
    let cap = raw.len() / stride;
    if cap > MAX_COMPACT_NODES {
        return Vec::new();
    }

    raw.chunks_exact(stride)
        .map(|chunk| {
            let mut id = [0u8; 20];
            id.copy_from_slice(&chunk[..20]);
            let addr = if ipv6 {
                let mut ip = [0u8; 16];
                ip.copy_from_slice(&chunk[20..36]);
                let port = u16::from_be_bytes([chunk[36], chunk[37]]);
                SocketAddr::new(std::net::IpAddr::from(ip), port)
            } else {
                let ip = std::net::Ipv4Addr::new(chunk[20], chunk[21], chunk[22], chunk[23]);
                let port = u16::from_be_bytes([chunk[24], chunk[25]]);
                SocketAddr::V4(std::net::SocketAddrV4::new(ip, port))
            };
            CompactNode { id, addr }
        })
        .collect()
}

pub fn decode_peer_values(value: &crate::bencode::BencodeValue) -> Vec<SocketAddr> {
    let Some(list) = value.as_list() else {
        return Vec::new();
    };
    if list.len() > MAX_COMPACT_PEERS {
        return Vec::new();
    }
    list.iter()
        .filter_map(|entry| {
            let bytes = entry.as_bytes()?;
            decode_compact_peer(bytes, bytes.len() == 18)
        })
        .collect()
}

fn decode_compact_peer(chunk: &[u8], ipv6: bool) -> Option<SocketAddr> {
    if ipv6 && chunk.len() == 18 {
        let mut ip = [0u8; 16];
        ip.copy_from_slice(&chunk[..16]);
        let port = u16::from_be_bytes([chunk[16], chunk[17]]);
        return Some(SocketAddr::new(std::net::IpAddr::from(ip), port));
    }
    if !ipv6 && chunk.len() == 6 {
        let ip = std::net::Ipv4Addr::new(chunk[0], chunk[1], chunk[2], chunk[3]);
        let port = u16::from_be_bytes([chunk[4], chunk[5]]);
        return Some(SocketAddr::V4(std::net::SocketAddrV4::new(ip, port)));
    }
    None
}

pub fn encode_peers(peers: &[SocketAddr], ipv6: bool) -> Vec<u8> {
    let stride = if ipv6 { 18 } else { 6 };
    let mut out = Vec::with_capacity(peers.len().min(MAX_COMPACT_PEERS) * stride);
    for peer in peers.iter().take(MAX_COMPACT_PEERS) {
        match peer {
            SocketAddr::V4(v4) if !ipv6 => {
                out.extend(v4.ip().octets());
                out.extend(v4.port().to_be_bytes());
            }
            SocketAddr::V6(v6) if ipv6 => {
                out.extend(v6.ip().octets());
                out.extend(v6.port().to_be_bytes());
            }
            _ => {}
        }
    }
    out
}

/// BEP 5 / BEP 32 `values` / `values6`: list of compact peer strings.
pub fn encode_peer_values_list(
    peers: &[SocketAddr],
    ipv6: bool,
) -> Option<crate::bencode::BencodeValue> {
    use crate::bencode::BencodeValue;
    let mut list = Vec::new();
    for peer in peers.iter().take(MAX_COMPACT_PEERS) {
        match peer {
            SocketAddr::V4(v4) if !ipv6 => {
                let mut bytes = Vec::with_capacity(6);
                bytes.extend(v4.ip().octets());
                bytes.extend(v4.port().to_be_bytes());
                list.push(BencodeValue::Bytes(bytes));
            }
            SocketAddr::V6(v6) if ipv6 => {
                let mut bytes = Vec::with_capacity(18);
                bytes.extend(v6.ip().octets());
                bytes.extend(v6.port().to_be_bytes());
                list.push(BencodeValue::Bytes(bytes));
            }
            _ => {}
        }
    }
    if list.is_empty() {
        None
    } else {
        Some(BencodeValue::List(list))
    }
}

pub fn encode_nodes(nodes: &[CompactNode], ipv6: bool) -> Vec<u8> {
    let stride = if ipv6 { 38 } else { 26 };
    let matching: Vec<&CompactNode> = nodes
        .iter()
        .filter(|node| match node.addr {
            SocketAddr::V4(_) => !ipv6,
            SocketAddr::V6(_) => ipv6,
        })
        .take(MAX_COMPACT_NODES)
        .collect();
    let mut out = vec![0u8; matching.len() * stride];
    for (idx, node) in matching.iter().enumerate() {
        let base = idx * stride;
        out[base..base + 20].copy_from_slice(&node.id);
        match node.addr {
            SocketAddr::V4(v4) => {
                out[base + 20..base + 24].copy_from_slice(&v4.ip().octets());
                out[base + 24..base + 26].copy_from_slice(&v4.port().to_be_bytes());
            }
            SocketAddr::V6(v6) => {
                out[base + 20..base + 36].copy_from_slice(&v6.ip().octets());
                out[base + 36..base + 38].copy_from_slice(&v6.port().to_be_bytes());
            }
        }
    }
    out
}

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

    #[test]
    fn rejects_oversized_compact_peer_blob() {
        let raw = vec![0u8; 6 * (MAX_COMPACT_PEERS + 1)];
        assert!(decode_peers(&raw, false).is_empty());
    }

    #[test]
    fn encode_nodes_skips_mismatched_family() {
        let v4 = CompactNode {
            id: [1u8; 20],
            addr: SocketAddr::from(([1, 2, 3, 4], 6881)),
        };
        let v6 = CompactNode {
            id: [2u8; 20],
            addr: SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 1], 6881)),
        };
        let encoded = encode_nodes(&[v4.clone(), v6.clone()], false);
        assert_eq!(encoded.len(), 26);
        let decoded = decode_nodes(&encoded, false);
        assert_eq!(decoded.len(), 1);
        assert_eq!(decoded[0].id, v4.id);

        let encoded6 = encode_nodes(&[v4, v6], true);
        assert_eq!(encoded6.len(), 38);
        assert_eq!(decode_nodes(&encoded6, true).len(), 1);
    }

    #[test]
    fn encode_peer_values_list_separates_families() {
        use crate::bencode::BencodeValue;
        let v4 = SocketAddr::from(([1, 2, 3, 4], 6881));
        let v6 = SocketAddr::from(([0x2001, 0xdb8, 0, 0, 0, 0, 0, 1], 6881));
        let list4 = encode_peer_values_list(&[v4, v6], false).expect("v4 list");
        let BencodeValue::List(items4) = list4 else {
            panic!("expected list");
        };
        assert_eq!(items4.len(), 1);
        assert_eq!(items4[0].as_bytes().map(|b| b.len()), Some(6));
        let list6 = encode_peer_values_list(&[v4, v6], true).expect("v6 list");
        let BencodeValue::List(items6) = list6 else {
            panic!("expected list");
        };
        assert_eq!(items6.len(), 1);
        assert_eq!(items6[0].as_bytes().map(|b| b.len()), Some(18));
    }
}