torrentdht 0.1.1

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

use tokio::io::AsyncWriteExt;

use crate::bencode::decode;
use crate::error::{Error, Result};
use crate::tracker::http::{http_body, parse_http_url, urlencode_bytes};
use crate::tracker::policy::{ensure_http_ok, resolve_tracker_socket};

#[derive(Debug, Clone, Copy, Default)]
pub struct ScrapeStats {
    pub complete: u32,
    pub downloaded: u32,
    pub incomplete: u32,
}

pub fn build_scrape_path(base: &str, info_hashes: &[[u8; 20]]) -> String {
    let (path, existing_query) = split_path_and_query(base);
    let scrape_path = announce_path_to_scrape(path);

    let hash_params: Vec<String> = info_hashes
        .iter()
        .map(|hash| format!("info_hash={}", urlencode_bytes(hash)))
        .collect();
    let params = hash_params.join("&");

    match existing_query {
        Some(q) => format!("{scrape_path}?{q}&{params}"),
        None => format!("{scrape_path}?{params}"),
    }
}

fn announce_path_to_scrape(path: &str) -> String {
    if let Some(base) = path.strip_suffix("/announce") {
        format!("{base}/scrape")
    } else if let Some(base) = path.strip_suffix("/announce.php") {
        format!("{base}/scrape.php")
    } else {
        format!("{path}/scrape")
    }
}

pub fn split_path_and_query(path: &str) -> (&str, Option<&str>) {
    if let Some((p, q)) = path.split_once('?') {
        (p, Some(q))
    } else {
        (path, None)
    }
}

pub fn parse_scrape_response(body: &[u8]) -> Result<HashMap<[u8; 20], ScrapeStats>> {
    let value = decode(body)?;
    let files = value
        .dict_get(b"files".as_ref())
        .and_then(|v| v.as_dict())
        .ok_or_else(|| Error::Tracker("scrape response missing files".into()))?;

    let mut out = HashMap::new();
    for (key, entry) in files {
        if key.len() != 20 {
            continue;
        }
        let mut hash = [0u8; 20];
        hash.copy_from_slice(key);
        let complete = entry
            .dict_get_str("complete")
            .and_then(|v| v.as_int())
            .unwrap_or(0) as u32;
        let downloaded = entry
            .dict_get_str("downloaded")
            .and_then(|v| v.as_int())
            .unwrap_or(0) as u32;
        let incomplete = entry
            .dict_get_str("incomplete")
            .and_then(|v| v.as_int())
            .unwrap_or(0) as u32;
        out.insert(
            hash,
            ScrapeStats {
                complete,
                downloaded,
                incomplete,
            },
        );
    }
    Ok(out)
}

pub async fn scrape_http(
    announce_url: &str,
    info_hashes: &[[u8; 20]],
    block_private: bool,
) -> Result<HashMap<[u8; 20], ScrapeStats>> {
    let (host, port, use_tls, path) = parse_http_url(announce_url)?;
    let request_target = build_scrape_path(&path, info_hashes);

    if use_tls {
        crate::tracker::https::scrape_https(
            &host,
            port,
            &request_target,
            block_private,
        )
        .await
    } else {
        scrape_http_raw(&host, port, &request_target, block_private).await
    }
}

async fn scrape_http_raw(
    host: &str,
    port: u16,
    request_target: &str,
    block_private: bool,
) -> Result<HashMap<[u8; 20], ScrapeStats>> {
    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_scrape_response(body)
}

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

    #[test]
    fn preserves_passkey_query_on_scrape() {
        let path = build_scrape_path(
            "/announce?passkey=abc123",
            &[[0xAB; 20]],
        );
        assert!(path.contains("passkey=abc123"));
        assert!(path.contains("info_hash="));
    }

    #[test]
    fn derives_scrape_from_announce_path() {
        let path = build_scrape_path("/announce", &[[0xCD; 20]]);
        assert!(path.contains("scrape"));
    }
}