use std::collections::{BTreeMap, HashSet};
use crate::bencode::{decode_prefix, encode, BencodeValue};
use crate::error::{Error, Result};
use crate::peer::pex::{decode_pex, encode_pex, PexDelta};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExtensionMessageId {
Handshake = 0,
Metadata = 1,
Pex = 2,
}
#[derive(Debug, Clone)]
pub enum ExtensionMessage {
Handshake(Vec<u8>),
Metadata(MetadataMessage),
Pex(PexDelta),
}
#[derive(Debug, Clone)]
pub enum MetadataMessage {
Request { piece: u32 },
Data { piece: u32, total_size: u32, data: Vec<u8> },
Reject { piece: u32 },
}
impl ExtensionMessage {
pub fn encode(&self, extension_id: u8) -> Vec<u8> {
match self {
Self::Handshake(dict) => encode_extension(extension_id, dict),
Self::Metadata(msg) => encode_extension(extension_id, &encode_metadata(msg)),
Self::Pex(delta) => {
encode_extension(extension_id, &encode_pex(delta).unwrap_or_default())
}
}
}
pub fn decode(
payload: &[u8],
extension_id: u8,
ut_metadata: Option<u8>,
ut_pex: Option<u8>,
) -> Result<Option<(u8, Self)>> {
if payload.len() > crate::security::MAX_EXTENDED_PAYLOAD {
return Err(Error::Peer("extended payload exceeds limit".into()));
}
if extension_id == 0 {
return Ok(Some((0, Self::Handshake(payload.to_vec()))));
}
if ut_pex == Some(extension_id) {
if let Ok(delta) = decode_pex(payload) {
return Ok(Some((extension_id, Self::Pex(delta))));
}
}
if ut_metadata == Some(extension_id) {
if let Ok(msg) = decode_metadata(payload) {
return Ok(Some((extension_id, Self::Metadata(msg))));
}
}
Ok(None)
}
}
fn encode_extension(id: u8, body: &[u8]) -> Vec<u8> {
let len = 1 + 1 + body.len();
let mut out = Vec::with_capacity(4 + len);
out.extend((len as u32).to_be_bytes());
out.push(20); out.push(id);
out.extend(body);
out
}
fn encode_metadata(msg: &MetadataMessage) -> Vec<u8> {
match msg {
MetadataMessage::Request { piece } => encode(&BencodeValue::Dict(BTreeMap::from([
(b"msg_type".to_vec(), BencodeValue::Int(0)),
(b"piece".to_vec(), BencodeValue::Int(i64::from(*piece))),
]))),
MetadataMessage::Reject { piece } => encode(&BencodeValue::Dict(BTreeMap::from([
(b"msg_type".to_vec(), BencodeValue::Int(2)),
(b"piece".to_vec(), BencodeValue::Int(i64::from(*piece))),
]))),
MetadataMessage::Data {
piece,
total_size,
data,
} => {
let header = encode(&BencodeValue::Dict(BTreeMap::from([
(b"msg_type".to_vec(), BencodeValue::Int(1)),
(b"piece".to_vec(), BencodeValue::Int(i64::from(*piece))),
(
b"total_size".to_vec(),
BencodeValue::Int(i64::from(*total_size)),
),
])));
let mut out = Vec::with_capacity(header.len() + data.len());
out.extend(header);
out.extend(data);
out
}
}
}
fn decode_metadata(input: &[u8]) -> Result<MetadataMessage> {
let (value, rest) =
decode_prefix(input, crate::security::DecodeLimits::NETWORK)?;
let msg_type = value
.dict_get_str("msg_type")
.and_then(|v| v.as_int())
.ok_or_else(|| Error::Metadata("missing msg_type".into()))?;
let piece = value
.dict_get_str("piece")
.and_then(|v| v.as_int())
.ok_or_else(|| Error::Metadata("missing piece".into()))? as u32;
match msg_type {
0 => Ok(MetadataMessage::Request { piece }),
1 => {
let total_size = value
.dict_get_str("total_size")
.and_then(|v| v.as_int())
.ok_or_else(|| Error::Metadata("missing total_size".into()))?
as u32;
Ok(MetadataMessage::Data {
piece,
total_size,
data: rest.to_vec(),
})
}
2 => Ok(MetadataMessage::Reject { piece }),
other => Err(Error::Metadata(format!("unknown msg_type {other}"))),
}
}
pub fn supports_extensions(reserved: &[u8; 8]) -> bool {
reserved[5] & 0x10 != 0
}
pub fn enable_extensions(reserved: &mut [u8; 8]) {
reserved[5] |= 0x10;
}
pub fn build_extension_handshake(metadata_size: u32) -> ExtensionMessage {
build_swarm_extension_handshake(Some(metadata_size))
}
pub fn build_swarm_extension_handshake(metadata_size: Option<u32>) -> ExtensionMessage {
let mut m = BTreeMap::from([(
b"ut_pex".to_vec(),
BencodeValue::Int(ExtensionMessageId::Pex as i64),
)]);
if metadata_size.is_some() {
m.insert(
b"ut_metadata".to_vec(),
BencodeValue::Int(ExtensionMessageId::Metadata as i64),
);
}
let mut dict = BTreeMap::from([(b"m".to_vec(), BencodeValue::Dict(m))]);
if let Some(size) = metadata_size {
dict.insert(b"metadata_size".to_vec(), BencodeValue::Int(size as i64));
}
ExtensionMessage::Handshake(encode(&BencodeValue::Dict(dict)))
}
pub fn parse_extension_handshake(payload: &[u8]) -> Result<(Option<u32>, Option<u8>, Option<u8>)> {
let value = crate::bencode::decode_with_limits(payload, crate::security::DecodeLimits::NETWORK)?;
let metadata_size = value
.dict_get_str("metadata_size")
.and_then(|v| v.as_int())
.map(|v| v as u32);
let m = value.dict_get(b"m".as_ref());
let ut_metadata = m
.and_then(|dict| extension_id_from_dict(dict, "ut_metadata"))
.or_else(|| extension_id_from_dict(&value, "ut_metadata"));
let ut_pex = m
.and_then(|dict| extension_id_from_dict(dict, "ut_pex"))
.or_else(|| extension_id_from_dict(&value, "ut_pex"));
Ok((metadata_size, ut_metadata, ut_pex))
}
fn extension_id_from_dict(value: &BencodeValue, key: &str) -> Option<u8> {
value
.dict_get_str(key)
.and_then(|v| v.as_int())
.filter(|&id| id > 0 && id <= i64::from(u8::MAX))
.map(|id| id as u8)
}
pub fn bitfield_has_piece(bitfield: &[u8], index: u32) -> bool {
let byte_index = (index / 8) as usize;
let bit = 7 - (index % 8);
bitfield
.get(byte_index)
.map(|byte| (byte >> bit) & 1 == 1)
.unwrap_or(false)
}
pub fn update_availability(availability: &mut [u32], bitfield: &[u8]) {
crate::wire::apply_bitfield(availability, bitfield);
}
pub fn pieces_in_bitfield(bitfield: &[u8], total: u32) -> HashSet<u32> {
let mut out = HashSet::new();
for index in 0..total {
if bitfield_has_piece(bitfield, index) {
out.insert(index);
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detects_extension_support() {
let mut reserved = [0u8; 8];
enable_extensions(&mut reserved);
assert!(supports_extensions(&reserved));
}
#[test]
fn handshake_advertises_ut_metadata_under_m() {
let msg = build_extension_handshake(4096);
let ExtensionMessage::Handshake(payload) = msg else {
panic!("expected handshake");
};
let (size, meta, pex) = parse_extension_handshake(&payload).expect("parse");
assert_eq!(size, Some(4096));
assert_eq!(meta, Some(ExtensionMessageId::Metadata as u8));
assert_eq!(pex, Some(ExtensionMessageId::Pex as u8));
}
#[test]
fn decode_uses_body_after_id_strip() {
let handshake = build_extension_handshake(100);
let wire = handshake.encode(0);
let body = &wire[6..];
let decoded = ExtensionMessage::decode(body, 0, None, None)
.expect("decode")
.expect("some");
assert!(matches!(decoded.1, ExtensionMessage::Handshake(_)));
}
#[test]
fn metadata_data_roundtrip_bep9() {
let msg = MetadataMessage::Data {
piece: 1,
total_size: 100,
data: b"hello-metadata-block".to_vec(),
};
let encoded = encode_metadata(&msg);
let decoded = decode_metadata(&encoded).expect("decode");
match decoded {
MetadataMessage::Data {
piece,
total_size,
data,
} => {
assert_eq!(piece, 1);
assert_eq!(total_size, 100);
assert_eq!(data, b"hello-metadata-block");
}
other => panic!("unexpected {other:?}"),
}
}
#[test]
fn metadata_request_is_valid_bencode() {
let encoded = encode_metadata(&MetadataMessage::Request { piece: 3 });
let value = crate::bencode::decode_with_limits(&encoded, crate::security::DecodeLimits::NETWORK)
.expect("bencode");
assert_eq!(
value.dict_get_str("msg_type").and_then(|v| v.as_int()),
Some(0)
);
assert_eq!(
value.dict_get_str("piece").and_then(|v| v.as_int()),
Some(3)
);
}
}