torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
mod http;
mod https;
mod policy;
mod scrape;
mod udp;

use std::net::SocketAddr;

pub use http::{
    build_announce_path, http_body, parse_http_url, parse_tracker_response, parse_udp_url,
    AnnounceResponse,
};
pub use policy::{ensure_http_ok, filter_peers_for_dial, is_blocked_ip, resolve_tracker_socket};
pub use scrape::{scrape_http, ScrapeStats};

use crate::error::Result;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AnnounceEvent {
    /// Periodic / heal announce — omit HTTP `event=` / UDP event 0.
    None,
    Started,
    Completed,
    Stopped,
}

#[allow(clippy::too_many_arguments)]
pub async fn announce(
    announce_url: &str,
    info_hash: &[u8; 20],
    peer_id: &[u8; 20],
    port: u16,
    uploaded: u64,
    downloaded: u64,
    left: u64,
    event: AnnounceEvent,
    block_private: bool,
    ipv6: Option<&[u8; 18]>,
    announce_ip: Option<std::net::Ipv4Addr>,
) -> Result<AnnounceResponse> {
    let mut response = if let Some(rest) = announce_url.strip_prefix("udp://") {
        let _ = rest;
        let (host, tracker_port) = parse_udp_url(announce_url)?;
        let tracker = policy::resolve_tracker_socket(&host, tracker_port, block_private)?;
        udp::announce_udp(
            tracker,
            info_hash,
            peer_id,
            port,
            uploaded,
            downloaded,
            left,
            event,
        )
        .await?
    } else {
        let (host, tracker_port, use_tls, path) = parse_http_url(announce_url)?;
        let request_target = http::build_announce_path(
            &path,
            info_hash,
            peer_id,
            port,
            uploaded,
            downloaded,
            left,
            event,
            ipv6,
            announce_ip,
        )?;

        if use_tls {
            https::announce_https(
                &host,
                tracker_port,
                &path,
                &request_target,
                block_private,
            )
            .await?
        } else {
            http::announce_http(
                &host,
                tracker_port,
                &path,
                &request_target,
                block_private,
            )
            .await?
        }
    };
    response.peers = policy::filter_peers_for_dial(response.peers, block_private);
    Ok(response)
}

/// Back-compat wrapper used by existing call sites.
#[allow(clippy::too_many_arguments)]
pub async fn announce_http(
    announce_url: &str,
    info_hash: &[u8; 20],
    peer_id: &[u8; 20],
    port: u16,
    uploaded: u64,
    downloaded: u64,
    left: u64,
    event: AnnounceEvent,
) -> Result<Vec<SocketAddr>> {
    Ok(announce(
        announce_url,
        info_hash,
        peer_id,
        port,
        uploaded,
        downloaded,
        left,
        event,
        true,
        None,
        None,
    )
    .await?
    .peers)
}

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

    #[test]
    fn routes_http_scheme() {
        let url = "http://tracker.example.com/announce";
        let parsed = parse_http_url(url).expect("parse");
        assert!(!parsed.2);
    }

    #[test]
    fn routes_https_scheme() {
        let url = "https://tracker.example.com/announce";
        let parsed = parse_http_url(url).expect("parse");
        assert!(parsed.2);
    }
}