torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use crate::bencode::decode_with_limits;
use crate::error::{Error, Result};
use crate::security::{validate_metadata_piece, DecodeLimits, MAX_METADATA_BYTES};
use crate::peer::{
    build_extension_handshake, parse_extension_handshake, ExtensionMessage, MetadataMessage,
    PeerConnection, PeerMessage,
};
use crate::torrent::{parse_info, TorrentInfo};

/// BEP 9 metadata piece size (16 KiB).
pub const METADATA_PIECE_SIZE: u32 = 16 * 1024;
const METADATA_BLOCK: u32 = METADATA_PIECE_SIZE;
/// Total Extended frames accepted while fetching metadata (noise + useful).
const MAX_EXTENDED_FRAMES: usize = 256;
/// Frames that are not handshake/metadata (budget for noise without starving data).
const MAX_NOISE_EXTENDED: usize = 128;
/// Non-extended wire messages while waiting.
const MAX_OTHER_MESSAGES: usize = 256;

/// Fetched info dict: parsed [`TorrentInfo`] plus the exact bencoded bytes (for ut_metadata serve).
pub struct FetchedMetadata {
    pub info: TorrentInfo,
    pub info_dict_bytes: Vec<u8>,
}

pub async fn fetch_metadata(conn: PeerConnection) -> Result<TorrentInfo> {
    Ok(fetch_metadata_with_bytes(conn).await?.info)
}

pub async fn fetch_metadata_with_bytes(mut conn: PeerConnection) -> Result<FetchedMetadata> {
    conn.send(&PeerMessage::Interested).await?;

    let mut metadata_size = None;
    let mut ut_metadata_id = None;
    let mut metadata = Vec::new();
    let mut received = Vec::new();
    let mut extended_seen = 0usize;
    let mut noise_extended = 0usize;
    let mut other_seen = 0usize;

    loop {
        if extended_seen >= MAX_EXTENDED_FRAMES || other_seen >= MAX_OTHER_MESSAGES {
            break;
        }
        let message = conn.recv().await?;
        match message {
            PeerMessage::Extended { id, payload } => {
                extended_seen += 1;
                if let Some((_, ExtensionMessage::Handshake(body))) =
                    ExtensionMessage::decode(&payload, id, None, None)?
                {
                    let (size, ext_id, _pex) = parse_extension_handshake(&body)?;
                    metadata_size = size;
                    ut_metadata_id = ext_id;
                    if let (Some(size), Some(ext_id)) = (metadata_size, ut_metadata_id) {
                        if size as usize > MAX_METADATA_BYTES {
                            return Err(Error::Metadata("metadata size exceeds limit".into()));
                        }
                        metadata.resize(size as usize, 0);
                        let pieces_total = size.div_ceil(METADATA_BLOCK);
                        received = vec![false; pieces_total as usize];
                        conn.send_extended(ext_id, &build_extension_handshake(size))
                            .await?;
                        request_all_metadata(&mut conn, ext_id, size).await?;
                    }
                } else if let Some((_ext_id, ExtensionMessage::Metadata(meta))) =
                    ExtensionMessage::decode(&payload, id, ut_metadata_id, None)?
                {
                    if let MetadataMessage::Data {
                        piece,
                        total_size,
                        data,
                    } = meta
                    {
                        validate_metadata_piece(piece, total_size, data.len())?;
                        let start = piece as usize * METADATA_BLOCK as usize;
                        if metadata.len() < total_size as usize {
                            metadata.resize(total_size as usize, 0);
                            let pieces_total = total_size.div_ceil(METADATA_BLOCK);
                            received.resize(pieces_total as usize, false);
                        }
                        let end = start.saturating_add(data.len()).min(metadata.len());
                        metadata[start..end].copy_from_slice(&data[..end - start]);
                        if (piece as usize) < received.len() {
                            received[piece as usize] = true;
                        }
                        if !received.is_empty() && received.iter().all(|&got| got) {
                            return parse_metadata(&metadata, total_size);
                        }
                    }
                } else {
                    noise_extended += 1;
                    if noise_extended >= MAX_NOISE_EXTENDED {
                        return Err(Error::Metadata(
                            "too many non-metadata extended messages".into(),
                        ));
                    }
                }
            }
            PeerMessage::Unchoke => {
                other_seen += 1;
                if let (Some(size), Some(ext_id)) = (metadata_size, ut_metadata_id) {
                    request_all_metadata(&mut conn, ext_id, size).await?;
                }
            }
            _ => {
                other_seen += 1;
            }
        }
    }

    Err(Error::Metadata("timed out waiting for metadata".into()))
}

/// Slice one BEP 9 metadata piece from the info-dict bytes, or `None` if out of range.
pub fn metadata_piece_data(info_dict_bytes: &[u8], piece: u32) -> Option<&[u8]> {
    let start = piece as usize * METADATA_PIECE_SIZE as usize;
    if start >= info_dict_bytes.len() {
        return None;
    }
    let end = (start + METADATA_PIECE_SIZE as usize).min(info_dict_bytes.len());
    Some(&info_dict_bytes[start..end])
}

/// Build a BEP 9 `Data` reply for a metadata piece request.
pub fn metadata_data_message(info_dict_bytes: &[u8], piece: u32) -> Option<MetadataMessage> {
    let data = metadata_piece_data(info_dict_bytes, piece)?;
    Some(MetadataMessage::Data {
        piece,
        total_size: info_dict_bytes.len() as u32,
        data: data.to_vec(),
    })
}

async fn request_all_metadata(
    conn: &mut PeerConnection,
    ext_id: u8,
    total_size: u32,
) -> Result<()> {
    let pieces = total_size.div_ceil(METADATA_BLOCK);
    for piece in 0..pieces {
        conn.send_extended(
            ext_id,
            &ExtensionMessage::Metadata(MetadataMessage::Request { piece }),
        )
        .await?;
    }
    Ok(())
}

fn parse_metadata(metadata: &[u8], total_size: u32) -> Result<FetchedMetadata> {
    let slice = metadata
        .get(..total_size as usize)
        .ok_or_else(|| Error::Metadata("metadata buffer shorter than total_size".into()))?;
    let info_value = decode_with_limits(slice, DecodeLimits::METADATA)?;
    let info = parse_info(&info_value)?;
    Ok(FetchedMetadata {
        info,
        info_dict_bytes: slice.to_vec(),
    })
}

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

    #[test]
    fn metadata_block_count() {
        assert_eq!(32_768u32.div_ceil(METADATA_BLOCK), 2);
    }
}