torrentdht 0.1.1

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

use tokio::io::AsyncWriteExt;

use crate::bencode::decode_with_limits;
use crate::error::{Error, Result};
use crate::security::DecodeLimits;
use crate::tracker::policy::{ensure_http_ok, resolve_tracker_socket};
use crate::tracker::AnnounceEvent;
use crate::wire::decode_peers_auto;

#[derive(Debug, Clone, Default)]
pub struct AnnounceResponse {
    pub peers: Vec<SocketAddr>,
    pub interval_secs: Option<u32>,
    pub min_interval_secs: Option<u32>,
}

pub async fn announce_http(
    host: &str,
    port: u16,
    _path: &str,
    request_target: &str,
    block_private: bool,
) -> Result<AnnounceResponse> {
    crate::security::reject_http_token("tracker host", host)
        .map_err(|err| Error::Tracker(err.to_string()))?;
    crate::security::reject_http_token("tracker request", request_target)
        .map_err(|err| Error::Tracker(err.to_string()))?;
    let addr = resolve_tracker_socket(host, port, block_private)?;
    let mut stream = crate::net::connect_pinned(addr).await?;
    let request = format!(
        "GET {request_target} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\n\r\n"
    );
    stream.write_all(request.as_bytes()).await?;
    let response =
        crate::net::read_capped(&mut stream, crate::security::MAX_TRACKER_HTTP_RESPONSE).await
            .map_err(|err| Error::Tracker(err.to_string()))?;
    ensure_http_ok(&response)?;
    let body = http_body(&response)?;
    parse_tracker_response(body)
}

#[allow(clippy::too_many_arguments)]
pub fn build_announce_path(
    base: &str,
    info_hash: &[u8; 20],
    peer_id: &[u8; 20],
    port: u16,
    uploaded: u64,
    downloaded: u64,
    left: u64,
    event: AnnounceEvent,
    ipv6: Option<&[u8; 18]>,
    announce_ip: Option<std::net::Ipv4Addr>,
) -> Result<String> {
    let event_str = match event {
        AnnounceEvent::None => None,
        AnnounceEvent::Started => Some("started"),
        AnnounceEvent::Completed => Some("completed"),
        AnnounceEvent::Stopped => Some("stopped"),
    };
    let (path, existing_query) = crate::tracker::scrape::split_path_and_query(base);
    let mut params = format!(
        "info_hash={}&peer_id={}&port={port}&uploaded={uploaded}&downloaded={downloaded}&left={left}&compact=1&numwant=50",
        urlencode_bytes(info_hash),
        urlencode_bytes(peer_id),
    );
    if let Some(ev) = event_str {
        params.push_str("&event=");
        params.push_str(ev);
    }
    if let Some(compact) = ipv6 {
        params.push_str("&ipv6=");
        params.push_str(&urlencode_bytes(compact));
    }
    if let Some(ip) = announce_ip {
        params.push_str("&ip=");
        params.push_str(&urlencode_bytes(&ip.octets()));
    }
    Ok(match existing_query {
        Some(q) => format!("{path}?{q}&{params}"),
        None => format!("{path}?{params}"),
    })
}

pub fn parse_tracker_response(body: &[u8]) -> Result<AnnounceResponse> {
    let value = decode_with_limits(body, DecodeLimits::TRACKER)?;
    if let Some(reason) = value
        .dict_get(b"failure reason".as_ref())
        .and_then(|v| v.as_bytes())
    {
        let text = String::from_utf8_lossy(reason);
        return Err(Error::Tracker(format!("tracker failure reason: {text}")));
    }
    let interval_secs = value
        .dict_get(b"interval".as_ref())
        .and_then(|v| v.as_int())
        .filter(|&v| v > 0)
        .map(|v| v as u32);
    let min_interval_secs = value
        .dict_get(b"min interval".as_ref())
        .and_then(|v| v.as_int())
        .filter(|&v| v > 0)
        .map(|v| v as u32);

    let peers = if let Some(raw) = value.dict_get(b"peers".as_ref()).and_then(|v| v.as_bytes()) {
        decode_peers_auto(raw)
    } else if let Some(list) = value.dict_get(b"peers".as_ref()).and_then(|v| v.as_list()) {
        let mut out = Vec::new();
        for entry in list.iter().take(crate::wire::MAX_COMPACT_PEERS) {
            let ip = entry
                .dict_get_str("ip")
                .and_then(|v| v.as_bytes())
                .and_then(|b| String::from_utf8(b.to_vec()).ok())
                .ok_or_else(|| Error::Tracker("peer entry missing ip".into()))?;
            let port = entry
                .dict_get_str("port")
                .and_then(|v| v.as_int())
                .ok_or_else(|| Error::Tracker("peer entry missing port".into()))? as u16;
            if let Ok(addr) = format!("{ip}:{port}").parse() {
                out.push(addr);
            }
        }
        out
    } else {
        Vec::new()
    };

    Ok(AnnounceResponse {
        peers,
        interval_secs,
        min_interval_secs,
    })
}

pub fn http_body(response: &[u8]) -> Result<&[u8]> {
    let header_end = response
        .windows(4)
        .position(|window| window == b"\r\n\r\n")
        .ok_or_else(|| Error::Tracker("tracker response missing headers".into()))?;
    Ok(&response[header_end + 4..])
}

pub fn parse_http_url(url: &str) -> Result<(String, u16, bool, String)> {
    let (use_tls, rest) = if let Some(rest) = url.strip_prefix("https://") {
        (true, rest)
    } else if let Some(rest) = url.strip_prefix("http://") {
        (false, rest)
    } else {
        return Err(Error::Tracker(format!("unsupported tracker url: {url}")));
    };
    let (host_port, path) = rest
        .split_once('/')
        .map(|(hp, p)| (hp, format!("/{p}")))
        .unwrap_or((rest, "/".into()));
    let (host, port) = if let Some((host, port)) = host_port.split_once(':') {
        (
            host.to_string(),
            port.parse::<u16>()
                .map_err(|_| Error::Tracker("invalid tracker port".into()))?,
        )
    } else {
        (host_port.to_string(), if use_tls { 443 } else { 80 })
    };
    Ok((host, port, use_tls, path))
}

pub fn parse_udp_url(url: &str) -> Result<(String, u16)> {
    let rest = url
        .strip_prefix("udp://")
        .ok_or_else(|| Error::Tracker(format!("unsupported udp tracker url: {url}")))?;
    let host_port = rest.split('/').next().unwrap_or(rest);
    if let Some((host, port)) = host_port.split_once(':') {
        let port = port
            .parse::<u16>()
            .map_err(|_| Error::Tracker("invalid udp tracker port".into()))?;
        return Ok((host.to_string(), port));
    }
    Ok((host_port.to_string(), 6969))
}

pub fn urlencode_bytes(bytes: &[u8]) -> String {
    bytes.iter().map(|byte| format!("%{byte:02X}")).collect()
}

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

    #[test]
    fn builds_announce_path() {
        let path = build_announce_path(
            "/announce",
            &[0xAB; 20],
            &[0xCD; 20],
            6881,
            0,
            0,
            1000,
            AnnounceEvent::Started,
            None,
            None,
        )
        .expect("path");
        assert!(path.contains("info_hash="));
        assert!(path.contains("event=started"));
    }

    #[test]
    fn includes_ipv6_when_present() {
        let compact = [0xABu8; 18];
        let path = build_announce_path(
            "/announce",
            &[0xAB; 20],
            &[0xCD; 20],
            6881,
            0,
            0,
            1000,
            AnnounceEvent::Started,
            Some(&compact),
            None,
        )
        .expect("path");
        assert!(path.contains("ipv6="));
    }

    #[test]
    fn preserves_passkey_in_announce_path() {
        let path = build_announce_path(
            "/announce?passkey=secret",
            &[0xAB; 20],
            &[0xCD; 20],
            6881,
            0,
            0,
            1000,
            AnnounceEvent::Started,
            None,
            None,
        )
        .expect("path");
        assert!(path.contains("passkey=secret"));
        assert!(path.contains("&info_hash=") || path.contains("?passkey=secret&info_hash="));
    }

    #[test]
    fn parses_udp_tracker_url() {
        let (host, port) = parse_udp_url("udp://tracker.example.com:8080/announce").expect("parse");
        assert_eq!(host, "tracker.example.com");
        assert_eq!(port, 8080);
        let (host, port) = parse_udp_url("udp://tracker.example.com/announce").expect("default port");
        assert_eq!(host, "tracker.example.com");
        assert_eq!(port, 6969);
    }

    #[test]
    fn rejects_failure_reason() {
        let body = b"d14:failure reason20:unregistered torrente";
        let err = parse_tracker_response(body).expect_err("failure");
        assert!(
            err.to_string().contains("failure reason"),
            "{err}"
        );
    }

    #[test]
    fn parses_interval_keys() {
        let body = b"d8:intervali1800e12:min intervali900e5:peers0:e";
        let resp = parse_tracker_response(body).expect("ok");
        assert_eq!(resp.interval_secs, Some(1800));
        assert_eq!(resp.min_interval_secs, Some(900));
        assert!(resp.peers.is_empty());
    }
}