torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::collections::{BTreeMap, HashSet};

use crate::bencode::{decode_prefix, encode, BencodeValue};
use crate::error::{Error, Result};
use crate::peer::pex::{decode_pex, encode_pex, PexDelta};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExtensionMessageId {
    Handshake = 0,
    Metadata = 1,
    Pex = 2,
}

#[derive(Debug, Clone)]
pub enum ExtensionMessage {
    Handshake(Vec<u8>),
    Metadata(MetadataMessage),
    Pex(PexDelta),
}

#[derive(Debug, Clone)]
pub enum MetadataMessage {
    Request { piece: u32 },
    Data { piece: u32, total_size: u32, data: Vec<u8> },
    Reject { piece: u32 },
}

impl ExtensionMessage {
    pub fn encode(&self, extension_id: u8) -> Vec<u8> {
        match self {
            Self::Handshake(dict) => encode_extension(extension_id, dict),
            Self::Metadata(msg) => encode_extension(extension_id, &encode_metadata(msg)),
            Self::Pex(delta) => {
                encode_extension(extension_id, &encode_pex(delta).unwrap_or_default())
            }
        }
    }

    /// Decode an extended message body.
    ///
    /// `payload` is the body **after** the extension message id byte has already
    /// been stripped by [`crate::peer::messages::PeerMessage`] (`Extended.id`).
    pub fn decode(
        payload: &[u8],
        extension_id: u8,
        ut_metadata: Option<u8>,
        ut_pex: Option<u8>,
    ) -> Result<Option<(u8, Self)>> {
        if payload.len() > crate::security::MAX_EXTENDED_PAYLOAD {
            return Err(Error::Peer("extended payload exceeds limit".into()));
        }
        if extension_id == 0 {
            return Ok(Some((0, Self::Handshake(payload.to_vec()))));
        }
        if ut_pex == Some(extension_id) {
            if let Ok(delta) = decode_pex(payload) {
                return Ok(Some((extension_id, Self::Pex(delta))));
            }
        }
        if ut_metadata == Some(extension_id) {
            if let Ok(msg) = decode_metadata(payload) {
                return Ok(Some((extension_id, Self::Metadata(msg))));
            }
        }
        // Unknown extension id: ignore rather than hard-fail.
        Ok(None)
    }
}

fn encode_extension(id: u8, body: &[u8]) -> Vec<u8> {
    let len = 1 + 1 + body.len();
    let mut out = Vec::with_capacity(4 + len);
    out.extend((len as u32).to_be_bytes());
    out.push(20); // extended message id
    out.push(id);
    out.extend(body);
    out
}

fn encode_metadata(msg: &MetadataMessage) -> Vec<u8> {
    match msg {
        MetadataMessage::Request { piece } => encode(&BencodeValue::Dict(BTreeMap::from([
            (b"msg_type".to_vec(), BencodeValue::Int(0)),
            (b"piece".to_vec(), BencodeValue::Int(i64::from(*piece))),
        ]))),
        MetadataMessage::Reject { piece } => encode(&BencodeValue::Dict(BTreeMap::from([
            (b"msg_type".to_vec(), BencodeValue::Int(2)),
            (b"piece".to_vec(), BencodeValue::Int(i64::from(*piece))),
        ]))),
        MetadataMessage::Data {
            piece,
            total_size,
            data,
        } => {
            // BEP 9: bencoded header dict, then raw piece bytes (not inside the dict).
            let header = encode(&BencodeValue::Dict(BTreeMap::from([
                (b"msg_type".to_vec(), BencodeValue::Int(1)),
                (b"piece".to_vec(), BencodeValue::Int(i64::from(*piece))),
                (
                    b"total_size".to_vec(),
                    BencodeValue::Int(i64::from(*total_size)),
                ),
            ])));
            let mut out = Vec::with_capacity(header.len() + data.len());
            out.extend(header);
            out.extend(data);
            out
        }
    }
}

fn decode_metadata(input: &[u8]) -> Result<MetadataMessage> {
    let (value, rest) =
        decode_prefix(input, crate::security::DecodeLimits::NETWORK)?;
    let msg_type = value
        .dict_get_str("msg_type")
        .and_then(|v| v.as_int())
        .ok_or_else(|| Error::Metadata("missing msg_type".into()))?;
    let piece = value
        .dict_get_str("piece")
        .and_then(|v| v.as_int())
        .ok_or_else(|| Error::Metadata("missing piece".into()))? as u32;
    match msg_type {
        0 => Ok(MetadataMessage::Request { piece }),
        1 => {
            let total_size = value
                .dict_get_str("total_size")
                .and_then(|v| v.as_int())
                .ok_or_else(|| Error::Metadata("missing total_size".into()))?
                as u32;
            Ok(MetadataMessage::Data {
                piece,
                total_size,
                data: rest.to_vec(),
            })
        }
        2 => Ok(MetadataMessage::Reject { piece }),
        other => Err(Error::Metadata(format!("unknown msg_type {other}"))),
    }
}

pub fn supports_extensions(reserved: &[u8; 8]) -> bool {
    reserved[5] & 0x10 != 0
}

pub fn enable_extensions(reserved: &mut [u8; 8]) {
    reserved[5] |= 0x10;
}

pub fn build_extension_handshake(metadata_size: u32) -> ExtensionMessage {
    build_swarm_extension_handshake(Some(metadata_size))
}

pub fn build_swarm_extension_handshake(metadata_size: Option<u32>) -> ExtensionMessage {
    // BEP 10: extension names live under `m`; `metadata_size` is top-level.
    let mut m = BTreeMap::from([(
        b"ut_pex".to_vec(),
        BencodeValue::Int(ExtensionMessageId::Pex as i64),
    )]);
    if metadata_size.is_some() {
        m.insert(
            b"ut_metadata".to_vec(),
            BencodeValue::Int(ExtensionMessageId::Metadata as i64),
        );
    }
    let mut dict = BTreeMap::from([(b"m".to_vec(), BencodeValue::Dict(m))]);
    if let Some(size) = metadata_size {
        dict.insert(b"metadata_size".to_vec(), BencodeValue::Int(size as i64));
    }
    ExtensionMessage::Handshake(encode(&BencodeValue::Dict(dict)))
}

pub fn parse_extension_handshake(payload: &[u8]) -> Result<(Option<u32>, Option<u8>, Option<u8>)> {
    let value = crate::bencode::decode_with_limits(payload, crate::security::DecodeLimits::NETWORK)?;
    let metadata_size = value
        .dict_get_str("metadata_size")
        .and_then(|v| v.as_int())
        .map(|v| v as u32);
    // Prefer BEP 10 `m` dict; fall back to legacy top-level keys for older peers.
    let m = value.dict_get(b"m".as_ref());
    let ut_metadata = m
        .and_then(|dict| extension_id_from_dict(dict, "ut_metadata"))
        .or_else(|| extension_id_from_dict(&value, "ut_metadata"));
    let ut_pex = m
        .and_then(|dict| extension_id_from_dict(dict, "ut_pex"))
        .or_else(|| extension_id_from_dict(&value, "ut_pex"));
    Ok((metadata_size, ut_metadata, ut_pex))
}

fn extension_id_from_dict(value: &BencodeValue, key: &str) -> Option<u8> {
    value
        .dict_get_str(key)
        .and_then(|v| v.as_int())
        .filter(|&id| id > 0 && id <= i64::from(u8::MAX))
        .map(|id| id as u8)
}

pub fn bitfield_has_piece(bitfield: &[u8], index: u32) -> bool {
    let byte_index = (index / 8) as usize;
    let bit = 7 - (index % 8);
    bitfield
        .get(byte_index)
        .map(|byte| (byte >> bit) & 1 == 1)
        .unwrap_or(false)
}

pub fn update_availability(availability: &mut [u32], bitfield: &[u8]) {
    crate::wire::apply_bitfield(availability, bitfield);
}

pub fn pieces_in_bitfield(bitfield: &[u8], total: u32) -> HashSet<u32> {
    let mut out = HashSet::new();
    for index in 0..total {
        if bitfield_has_piece(bitfield, index) {
            out.insert(index);
        }
    }
    out
}

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

    #[test]
    fn detects_extension_support() {
        let mut reserved = [0u8; 8];
        enable_extensions(&mut reserved);
        assert!(supports_extensions(&reserved));
    }

    #[test]
    fn handshake_advertises_ut_metadata_under_m() {
        let msg = build_extension_handshake(4096);
        let ExtensionMessage::Handshake(payload) = msg else {
            panic!("expected handshake");
        };
        let (size, meta, pex) = parse_extension_handshake(&payload).expect("parse");
        assert_eq!(size, Some(4096));
        assert_eq!(meta, Some(ExtensionMessageId::Metadata as u8));
        assert_eq!(pex, Some(ExtensionMessageId::Pex as u8));
    }

    #[test]
    fn decode_uses_body_after_id_strip() {
        let handshake = build_extension_handshake(100);
        let wire = handshake.encode(0);
        // length(4) + msg_id(1) + ext_id(1) + body
        let body = &wire[6..];
        let decoded = ExtensionMessage::decode(body, 0, None, None)
            .expect("decode")
            .expect("some");
        assert!(matches!(decoded.1, ExtensionMessage::Handshake(_)));
    }

    #[test]
    fn metadata_data_roundtrip_bep9() {
        let msg = MetadataMessage::Data {
            piece: 1,
            total_size: 100,
            data: b"hello-metadata-block".to_vec(),
        };
        let encoded = encode_metadata(&msg);
        let decoded = decode_metadata(&encoded).expect("decode");
        match decoded {
            MetadataMessage::Data {
                piece,
                total_size,
                data,
            } => {
                assert_eq!(piece, 1);
                assert_eq!(total_size, 100);
                assert_eq!(data, b"hello-metadata-block");
            }
            other => panic!("unexpected {other:?}"),
        }
    }

    #[test]
    fn metadata_request_is_valid_bencode() {
        let encoded = encode_metadata(&MetadataMessage::Request { piece: 3 });
        let value = crate::bencode::decode_with_limits(&encoded, crate::security::DecodeLimits::NETWORK)
            .expect("bencode");
        assert_eq!(
            value.dict_get_str("msg_type").and_then(|v| v.as_int()),
            Some(0)
        );
        assert_eq!(
            value.dict_get_str("piece").and_then(|v| v.as_int()),
            Some(3)
        );
    }
}