torrentdht 0.1.1

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

use tokio::net::UdpSocket;
use tokio::time::timeout;

use crate::error::{Error, Result};
use crate::tracker::AnnounceEvent;
use crate::wire::decode_peers_auto;

const PROTOCOL_ID: u64 = 0x4172_7109_1980;
const ACTION_CONNECT: u32 = 0;
const ACTION_ANNOUNCE: u32 = 1;
const ACTION_CONNECT_RESPONSE: u32 = 0;
const ACTION_ANNOUNCE_RESPONSE: u32 = 1;

#[allow(clippy::too_many_arguments)]
pub async fn announce_udp(
    tracker: SocketAddr,
    info_hash: &[u8; 20],
    peer_id: &[u8; 20],
    port: u16,
    uploaded: u64,
    downloaded: u64,
    left: u64,
    event: AnnounceEvent,
) -> Result<crate::tracker::AnnounceResponse> {
    // Connected UDP: kernel delivers only datagrams from `tracker`.
    let socket = UdpSocket::bind("0.0.0.0:0").await?;
    socket.connect(tracker).await?;
    let connection_id = connect(&socket, tracker).await?;
    announce_with_connection(
        &socket,
        tracker,
        connection_id,
        info_hash,
        peer_id,
        port,
        uploaded,
        downloaded,
        left,
        event,
    )
    .await
}

async fn connect(socket: &UdpSocket, tracker: SocketAddr) -> Result<u64> {
    let tx = udp_tx()?;
    let packet = build_connect(tx);
    socket.send(&packet).await?;

    let mut buf = [0u8; 16];
    let len = timeout(Duration::from_secs(5), socket.recv(&mut buf))
        .await
        .map_err(|_| Error::Tracker(format!("udp connect timed out for {tracker}")))?
        .map_err(Error::from)?;
    if len < 16 {
        return Err(Error::Tracker("udp connect response too short".into()));
    }
    let action = u32::from_be_bytes(buf[0..4].try_into().expect("action"));
    if action != ACTION_CONNECT_RESPONSE {
        return Err(Error::Tracker(format!("unexpected udp connect action {action}")));
    }
    if buf[4..8] != tx {
        return Err(Error::Tracker("udp connect transaction mismatch".into()));
    }
    Ok(u64::from_be_bytes(buf[8..16].try_into().expect("connection id")))
}

#[allow(clippy::too_many_arguments)]
async fn announce_with_connection(
    socket: &UdpSocket,
    tracker: SocketAddr,
    connection_id: u64,
    info_hash: &[u8; 20],
    peer_id: &[u8; 20],
    port: u16,
    uploaded: u64,
    downloaded: u64,
    left: u64,
    event: AnnounceEvent,
) -> Result<crate::tracker::AnnounceResponse> {
    let tx = udp_tx()?;
    let key = u32::from_be_bytes(crate::net::random_bytes::<4>()?);
    let packet = build_announce(
        connection_id,
        tx,
        info_hash,
        peer_id,
        port,
        uploaded,
        downloaded,
        left,
        event,
        key,
    );
    socket.send(&packet).await?;

    let mut buf = vec![0u8; 8192];
    let len = timeout(Duration::from_secs(5), socket.recv(&mut buf))
        .await
        .map_err(|_| Error::Tracker(format!("udp announce timed out for {tracker}")))?
        .map_err(Error::from)?;
    parse_announce_response(&buf[..len], &tx)
}

fn build_connect(transaction_id: [u8; 4]) -> [u8; 16] {
    let mut out = [0u8; 16];
    out[0..8].copy_from_slice(&PROTOCOL_ID.to_be_bytes());
    out[8..12].copy_from_slice(&ACTION_CONNECT.to_be_bytes());
    out[12..16].copy_from_slice(&transaction_id);
    out
}

#[allow(clippy::too_many_arguments)]
fn build_announce(
    connection_id: u64,
    transaction_id: [u8; 4],
    info_hash: &[u8; 20],
    peer_id: &[u8; 20],
    port: u16,
    uploaded: u64,
    downloaded: u64,
    left: u64,
    event: AnnounceEvent,
    key: u32,
) -> Vec<u8> {
    let mut out = Vec::with_capacity(98);
    out.extend(connection_id.to_be_bytes());
    out.extend(ACTION_ANNOUNCE.to_be_bytes());
    out.extend(transaction_id);
    out.extend(info_hash);
    out.extend(peer_id);
    out.extend(downloaded.to_be_bytes());
    out.extend(left.to_be_bytes());
    out.extend(uploaded.to_be_bytes());
    out.extend(event_code(event).to_be_bytes());
    out.extend(0u32.to_be_bytes()); // ip
    out.extend(key.to_be_bytes());
    out.extend((-1i32).to_be_bytes()); // num_want
    out.extend(port.to_be_bytes());
    out
}

fn parse_announce_response(
    buf: &[u8],
    expected_tx: &[u8; 4],
) -> Result<crate::tracker::AnnounceResponse> {
    if buf.len() < 20 {
        return Err(Error::Tracker("udp announce response too short".into()));
    }
    let action = u32::from_be_bytes(buf[0..4].try_into().expect("action"));
    if action != ACTION_ANNOUNCE_RESPONSE {
        return Err(Error::Tracker(format!("unexpected udp announce action {action}")));
    }
    if &buf[4..8] != expected_tx {
        return Err(Error::Tracker("udp announce transaction mismatch".into()));
    }
    let interval_secs = u32::from_be_bytes(buf[8..12].try_into().expect("interval"));
    Ok(crate::tracker::AnnounceResponse {
        peers: decode_peers_auto(&buf[20..]),
        interval_secs: Some(interval_secs).filter(|&v| v > 0),
        min_interval_secs: None,
    })
}

fn event_code(event: AnnounceEvent) -> u32 {
    match event {
        AnnounceEvent::None => 0,
        AnnounceEvent::Completed => 1,
        AnnounceEvent::Started => 2,
        AnnounceEvent::Stopped => 3,
    }
}

fn udp_tx() -> Result<[u8; 4]> {
    crate::net::random_bytes::<4>()
}

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

    #[test]
    fn connect_packet_size() {
        let packet = build_connect([1, 2, 3, 4]);
        assert_eq!(packet.len(), 16);
        assert_eq!(&packet[0..8], &PROTOCOL_ID.to_be_bytes());
    }

    #[test]
    fn announce_packet_layout() {
        let packet = build_announce(
            0x1234,
            [9, 9, 9, 9],
            &[1; 20],
            &[2; 20],
            6881,
            0,
            0,
            1000,
            AnnounceEvent::Started,
            0xAABB_CCDD,
        );
        assert_eq!(packet.len(), 98);
    }
}