torrentdht 0.1.1

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

use crate::error::{Error, Result};
use crate::torrent::{
    decode_base32_info_hash, info_hash_to_base32, InfoHash, InfoHashV2, MetaVersion, TorrentFile,
};

#[derive(Debug, Clone)]
pub struct MagnetLink {
    /// Wire / DHT identity (v1 SHA-1, or truncated SHA-256 for pure-v2).
    pub info_hash: InfoHash,
    /// Full BEP 52 SHA2-256 info-hash when `xt=urn:btmh:` is present (or hybrid emit).
    pub info_hash_v2: Option<InfoHashV2>,
    /// True when the magnet included `xt=urn:btih:`.
    pub has_btih: bool,
    pub display_name: Option<String>,
    pub trackers: Vec<String>,
    pub peers: Vec<SocketAddr>,
}

impl MagnetLink {
    pub fn from_torrent(torrent: &TorrentFile) -> Self {
        let has_btih = torrent.info.meta_version != MetaVersion::V2;
        let info_hash = torrent.info.info_hash;
        let info_hash_v2 = torrent.info.info_hash_v2.or_else(|| {
            if torrent.info.meta_version == MetaVersion::V1 || torrent.info_dict_bytes.is_empty() {
                None
            } else {
                Some(InfoHashV2::from_info_bytes(&torrent.info_dict_bytes))
            }
        });
        Self {
            info_hash,
            info_hash_v2,
            has_btih,
            display_name: Some(torrent.info.name.clone()),
            trackers: torrent.tracker_urls(),
            peers: Vec::new(),
        }
    }

    pub fn to_uri(&self) -> String {
        let mut uri = String::from("magnet:?");
        let mut first = true;
        if self.has_btih {
            uri.push_str(&format!(
                "xt=urn:btih:{}",
                info_hash_to_base32(&self.info_hash)
            ));
            first = false;
        }
        if let Some(v2) = &self.info_hash_v2 {
            if !first {
                uri.push('&');
            }
            uri.push_str(&format!("xt=urn:btmh:{}", v2.to_btmh_multihash_hex()));
            first = false;
        }
        if first {
            // Should not happen for a valid MagnetLink; keep a v1 topic as last resort.
            uri.push_str(&format!(
                "xt=urn:btih:{}",
                info_hash_to_base32(&self.info_hash)
            ));
        }
        if let Some(name) = &self.display_name {
            uri.push_str("&dn=");
            uri.push_str(&url_encode(name));
        }
        for tracker in &self.trackers {
            uri.push_str("&tr=");
            uri.push_str(&url_encode(tracker));
        }
        for peer in &self.peers {
            uri.push_str("&x.pe=");
            uri.push_str(&peer.to_string());
        }
        uri
    }
}

pub fn torrent_to_magnet(torrent: &TorrentFile) -> String {
    MagnetLink::from_torrent(torrent).to_uri()
}

pub fn parse_magnet(uri: &str) -> Result<MagnetLink> {
    let uri = uri
        .strip_prefix("magnet:?")
        .ok_or_else(|| Error::Torrent("magnet URI must start with magnet:?".into()))?;

    let mut info_hash_v1 = None;
    let mut info_hash_v2 = None;
    let mut display_name = None;
    let mut trackers = Vec::new();
    let mut peers = Vec::new();

    for param in uri.split('&') {
        let Some((key, value)) = param.split_once('=') else {
            continue;
        };
        let value = url_decode(value);
        match key {
            "xt" if value.starts_with("urn:btih:") => {
                let hash_str = value.trim_start_matches("urn:btih:");
                info_hash_v1 = Some(decode_v1_info_hash(hash_str)?);
            }
            "xt" if value.starts_with("urn:btmh:") => {
                let hash_str = value.trim_start_matches("urn:btmh:");
                info_hash_v2 = Some(InfoHashV2::from_btmh_multihash_hex(hash_str)?);
            }
            "dn" => display_name = Some(value),
            "tr" => trackers.push(value),
            "x.pe" => {
                if let Ok(addr) = value.parse::<SocketAddr>() {
                    peers.push(addr);
                }
            }
            _ => {}
        }
    }

    let has_btih = info_hash_v1.is_some();
    let info_hash = match (info_hash_v1, info_hash_v2) {
        (Some(v1), _) => v1,
        (None, Some(v2)) => v2.truncate_to_v1(),
        (None, None) => {
            return Err(Error::Torrent(
                "magnet missing xt=urn:btih or xt=urn:btmh".into(),
            ));
        }
    };

    Ok(MagnetLink {
        info_hash,
        info_hash_v2,
        has_btih,
        display_name,
        trackers,
        peers,
    })
}

fn decode_v1_info_hash(raw: &str) -> Result<InfoHash> {
    let raw = raw.trim();
    if raw.len() == 64 && raw.chars().all(|c| c.is_ascii_hexdigit()) {
        return Err(Error::Torrent(
            "rejected 64-hex digest as v1 btih (looks like a BEP 52 v2 hash); \
             use xt=urn:btmh:1220… for v2 magnets"
                .into(),
        ));
    }
    if raw.len() == 40 && raw.chars().all(|c| c.is_ascii_hexdigit()) {
        let mut bytes = [0u8; 20];
        for (idx, chunk) in raw.as_bytes().chunks(2).enumerate() {
            let hex = std::str::from_utf8(chunk)
                .map_err(|_| Error::Torrent("invalid info hash".into()))?;
            bytes[idx] = u8::from_str_radix(hex, 16)
                .map_err(|_| Error::Torrent("invalid hex info hash".into()))?;
        }
        return Ok(InfoHash::from_bytes(bytes));
    }

    if raw.len() == 32 {
        return decode_base32_info_hash(raw);
    }

    if raw.len() == 52 {
        return Err(Error::Torrent(
            "rejected 52-char base32 digest as v1 btih (looks like a BEP 52 v2 hash); \
             use xt=urn:btmh:1220… for v2 magnets"
                .into(),
        ));
    }

    Err(Error::Torrent(
        "v1 info hash must be 40 hex or 32 base32 under urn:btih".into(),
    ))
}

pub fn url_encode(input: &str) -> String {
    let mut out = String::with_capacity(input.len());
    for byte in input.bytes() {
        match byte {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                out.push(byte as char);
            }
            _ => out.push_str(&format!("%{byte:02X}")),
        }
    }
    out
}

fn url_decode(input: &str) -> String {
    let mut out = String::with_capacity(input.len());
    let bytes = input.as_bytes();
    let mut idx = 0;
    while idx < bytes.len() {
        if bytes[idx] == b'%' && idx + 2 < bytes.len() {
            if let Ok(byte) = u8::from_str_radix(
                std::str::from_utf8(&bytes[idx + 1..idx + 3]).unwrap_or(""),
                16,
            ) {
                out.push(byte as char);
                idx += 3;
                continue;
            }
        }
        out.push(bytes[idx] as char);
        idx += 1;
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::torrent::{InfoHash, InfoHashV2, TorrentFile, TorrentInfo};
    use std::path::PathBuf;

    #[test]
    fn parses_hex_info_hash() {
        let magnet = parse_magnet(
            "magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567&dn=test",
        )
        .expect("parse");
        assert_eq!(magnet.display_name.as_deref(), Some("test"));
        assert!(magnet.has_btih);
        assert!(magnet.info_hash_v2.is_none());
    }

    #[test]
    fn parses_base32_info_hash() {
        let hash = InfoHash::from_bytes([0xAB; 20]);
        let encoded = crate::torrent::info_hash_to_base32(&hash);
        let magnet = parse_magnet(&format!("magnet:?xt=urn:btih:{encoded}")).expect("parse");
        assert_eq!(magnet.info_hash, hash);
    }

    #[test]
    fn rejects_v2_hex_under_btih() {
        let hex = "0123456789abcdef".repeat(4);
        let err = parse_magnet(&format!("magnet:?xt=urn:btih:{hex}"));
        assert!(err.is_err());
    }

    #[test]
    fn parses_btmh_multihash() {
        let v2 = InfoHashV2::from_bytes([0xCD; 32]);
        let uri = format!("magnet:?xt=urn:btmh:{}", v2.to_btmh_multihash_hex());
        let magnet = parse_magnet(&uri).expect("parse");
        assert!(!magnet.has_btih);
        assert_eq!(magnet.info_hash_v2, Some(v2));
        assert_eq!(magnet.info_hash, v2.truncate_to_v1());
    }

    #[test]
    fn parses_hybrid_btih_and_btmh() {
        let v1 = InfoHash::from_bytes([0x11; 20]);
        let v2 = InfoHashV2::from_bytes([0x22; 32]);
        let uri = format!(
            "magnet:?xt=urn:btih:{}&xt=urn:btmh:{}",
            crate::torrent::info_hash_to_base32(&v1),
            v2.to_btmh_multihash_hex()
        );
        let magnet = parse_magnet(&uri).expect("parse");
        assert!(magnet.has_btih);
        assert_eq!(magnet.info_hash, v1);
        assert_eq!(magnet.info_hash_v2, Some(v2));
    }

    #[test]
    fn roundtrips_magnet_uri() {
        let torrent = TorrentFile {
            announce: Some("http://example.com/announce".into()),
            trackers: vec!["http://example.com/announce".into()],
            web_seeds: Vec::new(),
            info: TorrentInfo {
                info_hash: InfoHash::from_bytes([0xAB; 20]),
                info_hash_v2: None,
                name: "my file".into(),
                piece_length: 16384,
                pieces: vec![[0; 20]],
                files: vec![(PathBuf::from("my file"), 100)],
                total_len: 100,
                private: false,
                meta_version: crate::torrent::MetaVersion::V1,
                v2: None,
            },
            signature: None,
            info_dict_bytes: Vec::new(),
        };
        let uri = torrent_to_magnet(&torrent);
        assert!(uri.contains("xt=urn:btih:"));
        assert!(!uri.contains("btmh"));
        assert!(uri.contains("dn=my%20file"));
        assert!(uri.contains("tr=http%3A%2F%2Fexample.com%2Fannounce"));
        let parsed = parse_magnet(&uri).expect("parse");
        assert_eq!(parsed.info_hash, torrent.info.info_hash);
        assert_eq!(parsed.display_name.as_deref(), Some("my file"));
    }
}