use std::collections::BTreeMap;
use tracing::debug;
use crate::bittorrent::bencode::codec::BencodeValue;
#[derive(Debug, Clone, PartialEq)]
pub struct ExtensionHandshake {
m_dict: BTreeMap<Vec<u8>, BencodeValue>,
v: Option<String>,
metadata_size: Option<u32>,
port: Option<u16>,
reqq: u32,
}
const DEFAULT_UT_METADATA_ID: u8 = 1;
const DEFAULT_UT_PEX_ID: u8 = 2;
const DEFAULT_REQQ: u32 = 500;
const DEFAULT_CLIENT_VERSION: &str = crate::identity::DEFAULT_PEER_AGENT;
const MAX_METADATA_SIZE: u32 = 8 * 1024 * 1024;
impl ExtensionHandshake {
pub fn new() -> Self {
let mut m_dict = BTreeMap::new();
m_dict.insert(
b"ut_metadata".to_vec(),
BencodeValue::Int(DEFAULT_UT_METADATA_ID as i64),
);
m_dict.insert(
b"ut_pex".to_vec(),
BencodeValue::Int(DEFAULT_UT_PEX_ID as i64),
);
Self {
m_dict,
v: Some(DEFAULT_CLIENT_VERSION.to_string()),
metadata_size: None,
port: None,
reqq: DEFAULT_REQQ,
}
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut root = BTreeMap::new();
if let Some(ref v) = self.v {
root.insert(b"v".to_vec(), BencodeValue::Bytes(v.as_bytes().to_vec()));
}
if let Some(p) = self.port {
root.insert(b"p".to_vec(), BencodeValue::Int(p as i64));
}
root.insert(b"m".to_vec(), BencodeValue::Dict(self.m_dict.clone()));
if let Some(ms) = self.metadata_size {
root.insert(b"metadata_size".to_vec(), BencodeValue::Int(ms as i64));
}
root.insert(b"reqq".to_vec(), BencodeValue::Int(self.reqq as i64));
BencodeValue::Dict(root).encode()
}
pub fn from_bytes(data: &[u8]) -> Result<Self, String> {
let (val, consumed) = BencodeValue::decode(data)
.map_err(|e| format!("Failed to decode extension handshake: {}", e))?;
if consumed != data.len() {
debug!(
"Extension handshake: decoded {} bytes, total {} bytes (trailing data ignored)",
consumed,
data.len()
);
}
let dict = val
.as_dict()
.ok_or("Extension handshake payload is not a dict")?;
let m_dict = dict
.get(b"m".as_slice())
.and_then(BencodeValue::as_dict)
.cloned()
.unwrap_or_default();
let reqq = dict
.get(b"reqq".as_slice())
.and_then(|v| v.as_int())
.and_then(|i| u32::try_from(i).ok())
.unwrap_or(DEFAULT_REQQ);
let v = dict
.get(b"v".as_slice())
.and_then(|v| v.as_str())
.map(|s| s.to_string());
let port = dict
.get(b"p".as_slice())
.and_then(|v| v.as_int())
.filter(|&i| i > 0 && i <= u16::MAX as i64)
.and_then(|i| u16::try_from(i).ok());
let metadata_size = dict
.get(b"metadata_size".as_slice())
.and_then(|v| v.as_int())
.filter(|&i| i > 0 && i <= MAX_METADATA_SIZE as i64)
.and_then(|i| u32::try_from(i).ok());
Ok(Self {
m_dict,
v,
metadata_size,
port,
reqq,
})
}
pub fn ut_metadata_id(&self) -> Option<u8> {
self.m_dict
.get(b"ut_metadata".as_slice())
.and_then(|v| v.as_int())
.and_then(|i| u8::try_from(i).ok())
}
pub fn ut_pex_id(&self) -> Option<u8> {
self.m_dict
.get(b"ut_pex".as_slice())
.and_then(|v| v.as_int())
.and_then(|i| u8::try_from(i).ok())
}
pub fn with_ut_metadata(&mut self, id: u8) -> &mut Self {
self.m_dict
.insert(b"ut_metadata".to_vec(), BencodeValue::Int(id as i64));
self
}
pub fn with_ut_pex(&mut self, id: u8) -> &mut Self {
self.m_dict
.insert(b"ut_pex".to_vec(), BencodeValue::Int(id as i64));
self
}
pub fn reqq(&self) -> u32 {
self.reqq
}
pub fn with_reqq(&mut self, reqq: u32) -> &mut Self {
self.reqq = reqq;
self
}
pub fn v(&self) -> Option<&str> {
self.v.as_deref()
}
pub fn with_version(&mut self, v: impl Into<String>) -> &mut Self {
self.v = Some(v.into());
self
}
pub fn without_version(&mut self) -> &mut Self {
self.v = None;
self
}
pub fn metadata_size(&self) -> Option<u32> {
self.metadata_size
}
pub fn with_metadata_size(&mut self, size: u32) -> &mut Self {
self.metadata_size = Some(size);
self
}
pub fn port(&self) -> Option<u16> {
self.port
}
pub fn with_port(&mut self, port: u16) -> &mut Self {
self.port = Some(port);
self
}
pub fn m_dict(&self) -> &BTreeMap<Vec<u8>, BencodeValue> {
&self.m_dict
}
}
impl Default for ExtensionHandshake {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_handshake_default_creation() {
let hs = ExtensionHandshake::new();
assert_eq!(hs.ut_metadata_id(), Some(1));
assert_eq!(hs.ut_pex_id(), Some(2));
assert_eq!(hs.reqq(), 500);
assert_eq!(hs.v(), Some(DEFAULT_CLIENT_VERSION));
assert_eq!(hs.metadata_size(), None);
assert_eq!(hs.port(), None);
}
#[test]
fn test_handshake_default_trait() {
let hs = ExtensionHandshake::default();
assert_eq!(hs.ut_metadata_id(), Some(1));
assert_eq!(hs.ut_pex_id(), Some(2));
assert_eq!(hs.v(), Some(DEFAULT_CLIENT_VERSION));
}
#[test]
fn test_handshake_serialization_roundtrip() {
let hs = ExtensionHandshake::new();
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.ut_metadata_id(), Some(1));
assert_eq!(parsed.ut_pex_id(), Some(2));
assert_eq!(parsed.v(), Some(DEFAULT_CLIENT_VERSION));
assert_eq!(parsed.metadata_size(), None);
assert_eq!(parsed.port(), None);
}
#[test]
fn test_handshake_with_custom_ext_ids() {
let mut hs = ExtensionHandshake::new();
hs.with_ut_metadata(5).with_ut_pex(7);
assert_eq!(hs.ut_metadata_id(), Some(5));
assert_eq!(hs.ut_pex_id(), Some(7));
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.ut_metadata_id(), Some(5));
assert_eq!(parsed.ut_pex_id(), Some(7));
}
#[test]
fn test_handshake_without_m_key_has_no_extension_ids() {
let mut dict = BTreeMap::new();
dict.insert(b"reqq".to_vec(), BencodeValue::Int(500));
let bytes = BencodeValue::Dict(dict).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.ut_metadata_id(), None);
assert_eq!(parsed.ut_pex_id(), None);
assert_eq!(parsed.reqq(), 500);
}
#[test]
fn test_handshake_m_not_dict_keeps_other_fields() {
let mut dict = BTreeMap::new();
dict.insert(b"m".to_vec(), BencodeValue::Int(42));
dict.insert(
b"v".to_vec(),
BencodeValue::Bytes(b"remote-agent/2.3".to_vec()),
);
dict.insert(b"reqq".to_vec(), BencodeValue::Int(17));
let bytes = BencodeValue::Dict(dict).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.ut_metadata_id(), None);
assert_eq!(parsed.ut_pex_id(), None);
assert_eq!(parsed.v(), Some("remote-agent/2.3"));
assert_eq!(parsed.reqq(), 17);
}
#[test]
fn test_handshake_missing_ut_metadata() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_pex".to_vec(), BencodeValue::Int(3));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert!(parsed.ut_metadata_id().is_none());
assert_eq!(parsed.ut_pex_id(), Some(3));
}
#[test]
fn test_handshake_missing_ut_pex() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.ut_metadata_id(), Some(1));
assert!(parsed.ut_pex_id().is_none());
}
#[test]
fn test_handshake_invalid_bencode() {
let result = ExtensionHandshake::from_bytes(b"not bencoded");
assert!(result.is_err());
}
#[test]
fn test_handshake_empty_input() {
let result = ExtensionHandshake::from_bytes(b"");
assert!(result.is_err());
}
#[test]
fn test_handshake_bencode_wire_format() {
let hs = ExtensionHandshake::new();
let bytes = hs.to_bytes();
assert_eq!(bytes[0], b'd');
assert_eq!(bytes[bytes.len() - 1], b'e');
let s = String::from_utf8_lossy(&bytes);
assert!(s.contains("ut_metadata"));
assert!(s.contains("ut_pex"));
assert!(s.contains("reqq"));
assert!(s.contains(DEFAULT_CLIENT_VERSION));
assert!(!s.contains("metadata_size"));
}
#[test]
fn test_handshake_reqq_parsed_from_peer() {
let mut hs = ExtensionHandshake::new();
hs.with_reqq(1000);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.reqq(), 1000);
}
#[test]
fn test_handshake_reqq_default_when_missing() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
m_dict.insert(b"ut_pex".to_vec(), BencodeValue::Int(2));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.reqq(), 500);
}
#[test]
fn test_handshake_version_roundtrip() {
let mut hs = ExtensionHandshake::new();
hs.with_version("test-peer/1.0");
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.v(), Some("test-peer/1.0"));
}
#[test]
fn test_handshake_version_default() {
let hs = ExtensionHandshake::new();
assert_eq!(hs.v(), Some(DEFAULT_CLIENT_VERSION));
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.v(), Some(DEFAULT_CLIENT_VERSION));
}
#[test]
fn test_handshake_without_version() {
let mut hs = ExtensionHandshake::new();
hs.without_version();
assert_eq!(hs.v(), None);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.v(), None);
}
#[test]
fn test_handshake_metadata_size_roundtrip() {
let mut hs = ExtensionHandshake::new();
hs.with_metadata_size(12345);
assert_eq!(hs.metadata_size(), Some(12345));
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.metadata_size(), Some(12345));
}
#[test]
fn test_handshake_metadata_size_not_present() {
let hs = ExtensionHandshake::new();
assert_eq!(hs.metadata_size(), None);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.metadata_size(), None);
}
#[test]
fn test_handshake_metadata_size_zero_rejected() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(b"metadata_size".to_vec(), BencodeValue::Int(0));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.metadata_size(), None);
}
#[test]
fn test_handshake_metadata_size_negative_rejected() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(b"metadata_size".to_vec(), BencodeValue::Int(-1));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.metadata_size(), None);
}
#[test]
fn test_handshake_metadata_size_max_8mib() {
let max_size = 8 * 1024 * 1024; let mut hs = ExtensionHandshake::new();
hs.with_metadata_size(max_size);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.metadata_size(), Some(max_size));
}
#[test]
fn test_handshake_metadata_size_over_8mib_rejected() {
let oversized = 8 * 1024 * 1024 + 1;
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(
b"metadata_size".to_vec(),
BencodeValue::Int(oversized as i64),
);
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.metadata_size(), None);
}
#[test]
fn test_handshake_port_roundtrip() {
let mut hs = ExtensionHandshake::new();
hs.with_port(6881);
assert_eq!(hs.port(), Some(6881));
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.port(), Some(6881));
}
#[test]
fn test_handshake_port_not_present() {
let hs = ExtensionHandshake::new();
assert_eq!(hs.port(), None);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.port(), None);
}
#[test]
fn test_handshake_port_zero_rejected() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(b"p".to_vec(), BencodeValue::Int(0));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.port(), None);
}
#[test]
fn test_handshake_port_negative_rejected() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(b"p".to_vec(), BencodeValue::Int(-1));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.port(), None);
}
#[test]
fn test_handshake_port_max_valid() {
let mut hs = ExtensionHandshake::new();
hs.with_port(65535);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.port(), Some(65535));
}
#[test]
fn test_handshake_all_fields_roundtrip() {
let mut hs = ExtensionHandshake::new();
hs.with_version("test-peer/1.0")
.with_port(6881)
.with_metadata_size(45678)
.with_reqq(1000)
.with_ut_metadata(3)
.with_ut_pex(4);
let bytes = hs.to_bytes();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.v(), Some("test-peer/1.0"));
assert_eq!(parsed.port(), Some(6881));
assert_eq!(parsed.metadata_size(), Some(45678));
assert_eq!(parsed.reqq(), 1000);
assert_eq!(parsed.ut_metadata_id(), Some(3));
assert_eq!(parsed.ut_pex_id(), Some(4));
}
#[test]
fn test_handshake_peer_message_with_all_fields() {
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(2));
m_dict.insert(b"ut_pex".to_vec(), BencodeValue::Int(3));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(
b"v".to_vec(),
BencodeValue::Bytes(b"qBittorrent/4.5.2".to_vec()),
);
root.insert(b"p".to_vec(), BencodeValue::Int(6969));
root.insert(b"metadata_size".to_vec(), BencodeValue::Int(98765));
root.insert(b"reqq".to_vec(), BencodeValue::Int(250));
let bytes = BencodeValue::Dict(root).encode();
let parsed = ExtensionHandshake::from_bytes(&bytes).unwrap();
assert_eq!(parsed.v(), Some("qBittorrent/4.5.2"));
assert_eq!(parsed.port(), Some(6969));
assert_eq!(parsed.metadata_size(), Some(98765));
assert_eq!(parsed.reqq(), 250);
assert_eq!(parsed.ut_metadata_id(), Some(2));
assert_eq!(parsed.ut_pex_id(), Some(3));
}
}