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 {
pub info_hash: InfoHash,
pub info_hash_v2: Option<InfoHashV2>,
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 {
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"));
}
}