use std::collections::BTreeMap;
use crate::bittorrent::bencode::codec::BencodeValue;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UtMetadataMessage {
Request { piece: u32 },
Data {
piece: u32,
total_size: u32,
data: Vec<u8>,
},
Reject { piece: u32 },
}
impl UtMetadataMessage {
pub fn to_payload(&self) -> Vec<u8> {
let mut dict = BTreeMap::new();
match self {
UtMetadataMessage::Request { piece } => {
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(0));
dict.insert(b"piece".to_vec(), BencodeValue::Int(*piece as i64));
}
UtMetadataMessage::Data {
piece,
total_size,
data: _,
} => {
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(1));
dict.insert(b"piece".to_vec(), BencodeValue::Int(*piece as i64));
dict.insert(
b"total_size".to_vec(),
BencodeValue::Int(*total_size as i64),
);
}
UtMetadataMessage::Reject { piece } => {
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(2));
dict.insert(b"piece".to_vec(), BencodeValue::Int(*piece as i64));
}
}
let mut payload = BencodeValue::Dict(dict).encode();
if let UtMetadataMessage::Data { data, .. } = self {
payload.extend_from_slice(data);
}
payload
}
pub fn from_payload(payload: &[u8]) -> Result<Self, String> {
let (val, consumed) = BencodeValue::decode(payload)
.map_err(|e| format!("Failed to decode ut_metadata payload: {}", e))?;
let dict = val
.as_dict()
.ok_or("ut_metadata payload is not a bencoded dict")?;
let msg_type = dict
.get(b"msg_type".as_slice())
.and_then(|v| v.as_int())
.ok_or("Missing 'msg_type' in ut_metadata payload")?;
let piece = dict
.get(b"piece".as_slice())
.and_then(|v| v.as_int())
.filter(|value| *value >= 0)
.and_then(|value| u32::try_from(value).ok())
.ok_or("Missing or invalid 'piece' in ut_metadata payload")?;
match msg_type {
0 => Ok(UtMetadataMessage::Request { piece }),
1 => {
let total_size = dict
.get(b"total_size".as_slice())
.and_then(|v| v.as_int())
.filter(|value| *value >= 0)
.and_then(|value| u32::try_from(value).ok())
.ok_or("Missing or invalid 'total_size' in ut_metadata Data message")?;
if consumed == payload.len() {
return Err("Missing data in ut_metadata Data message".to_string());
}
let data = payload[consumed..].to_vec();
Ok(UtMetadataMessage::Data {
piece,
total_size,
data,
})
}
2 => Ok(UtMetadataMessage::Reject { piece }),
_ => Err(format!("Unknown ut_metadata msg_type: {}", msg_type)),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_ut_metadata_request_roundtrip() {
let msg = UtMetadataMessage::Request { piece: 0 };
let payload = msg.to_payload();
let parsed = UtMetadataMessage::from_payload(&payload).unwrap();
assert_eq!(parsed, msg);
}
#[test]
fn test_ut_metadata_request_nonzero_piece() {
let msg = UtMetadataMessage::Request { piece: 42 };
let payload = msg.to_payload();
let parsed = UtMetadataMessage::from_payload(&payload).unwrap();
assert_eq!(parsed, UtMetadataMessage::Request { piece: 42 });
}
#[test]
fn test_ut_metadata_data_roundtrip() {
let metadata_piece = b"fake torrent metadata bytes".to_vec();
let msg = UtMetadataMessage::Data {
piece: 3,
total_size: 50000,
data: metadata_piece,
};
let payload = msg.to_payload();
let parsed = UtMetadataMessage::from_payload(&payload).unwrap();
assert_eq!(parsed, msg);
}
#[test]
fn test_ut_metadata_data_without_payload_is_rejected() {
let msg = UtMetadataMessage::Data {
piece: 0,
total_size: 0,
data: Vec::new(),
};
let payload = msg.to_payload();
let error = UtMetadataMessage::from_payload(&payload).unwrap_err();
assert!(error.contains("Missing data"));
}
#[test]
fn test_ut_metadata_reject_roundtrip() {
let msg = UtMetadataMessage::Reject { piece: 7 };
let payload = msg.to_payload();
let parsed = UtMetadataMessage::from_payload(&payload).unwrap();
assert_eq!(parsed, msg);
}
#[test]
fn test_ut_metadata_missing_msg_type() {
let mut dict = BTreeMap::new();
dict.insert(b"piece".to_vec(), BencodeValue::Int(0));
let payload = BencodeValue::Dict(dict).encode();
let result = UtMetadataMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("msg_type"));
}
#[test]
fn test_ut_metadata_missing_piece() {
let mut dict = BTreeMap::new();
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(0));
let payload = BencodeValue::Dict(dict).encode();
let result = UtMetadataMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("piece"));
}
#[test]
fn test_ut_metadata_data_missing_total_size() {
let mut dict = BTreeMap::new();
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(1));
dict.insert(b"piece".to_vec(), BencodeValue::Int(0));
let payload = BencodeValue::Dict(dict).encode();
let result = UtMetadataMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("total_size"));
}
#[test]
fn test_ut_metadata_unknown_msg_type() {
let mut dict = BTreeMap::new();
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(99));
dict.insert(b"piece".to_vec(), BencodeValue::Int(0));
let payload = BencodeValue::Dict(dict).encode();
let result = UtMetadataMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("Unknown"));
}
#[test]
fn test_ut_metadata_negative_piece_is_rejected() {
let mut dict = BTreeMap::new();
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(0));
dict.insert(b"piece".to_vec(), BencodeValue::Int(-1));
let payload = BencodeValue::Dict(dict).encode();
let error = UtMetadataMessage::from_payload(&payload).unwrap_err();
assert!(error.contains("piece"));
}
#[test]
fn test_ut_metadata_negative_total_size_is_rejected() {
let mut dict = BTreeMap::new();
dict.insert(b"msg_type".to_vec(), BencodeValue::Int(1));
dict.insert(b"piece".to_vec(), BencodeValue::Int(0));
dict.insert(b"total_size".to_vec(), BencodeValue::Int(-1));
let mut payload = BencodeValue::Dict(dict).encode();
payload.push(0);
let error = UtMetadataMessage::from_payload(&payload).unwrap_err();
assert!(error.contains("total_size"));
}
#[test]
fn test_ut_metadata_invalid_bencode() {
let result = UtMetadataMessage::from_payload(b"garbage");
assert!(result.is_err());
}
}