use aria2_protocol::bittorrent::message::extension::{
ExtensionHandshake, UtMetadataMessage, UtPexMessage,
};
use tracing::{trace, warn};
use super::{ExtensionRegistry, ExtensionUpdate, UT_METADATA_NAME, UT_PEX_NAME};
impl ExtensionRegistry {
pub fn peer_ut_metadata_id(&self) -> Option<u8> {
self.peer_id_to_name
.iter()
.find(|(_, name)| name.as_ref() == UT_METADATA_NAME)
.map(|(&id, _)| id)
}
pub fn peer_ut_pex_id(&self) -> Option<u8> {
self.peer_id_to_name
.iter()
.find(|(_, name)| name.as_ref() == UT_PEX_NAME)
.map(|(&id, _)| id)
}
pub fn local_ut_metadata_id(&self) -> u8 {
self.local_ut_metadata_id
}
pub fn local_ut_pex_id(&self) -> u8 {
self.local_ut_pex_id
}
pub fn is_extension_enabled(&self, ext_id: u8) -> bool {
self.peer_id_to_name.contains_key(&ext_id)
}
pub fn extension_name_for_id(&self, ext_id: u8) -> Option<&[u8]> {
self.peer_id_to_name.get(&ext_id).map(Box::as_ref)
}
pub fn reqq(&self) -> u32 {
self.reqq
}
pub fn supports_ut_metadata(&self) -> bool {
self.peer_ut_metadata_id().is_some()
}
pub fn supports_ut_pex(&self) -> bool {
self.peer_ut_pex_id().is_some()
}
}
pub fn dispatch_extension_message(
registry: &mut ExtensionRegistry,
ext_id: u8,
payload: &[u8],
) -> Option<ExtensionUpdate> {
if ext_id == 0 {
match ExtensionHandshake::from_bytes(payload) {
Ok(handshake) => {
let ut_metadata_id = handshake.ut_metadata_id();
let ut_pex_id = handshake.ut_pex_id();
let reqq = handshake.reqq();
registry.update_from_peer_handshake(&handshake);
Some(ExtensionUpdate::HandshakeReceived {
ut_metadata_id,
ut_pex_id,
reqq,
})
}
Err(e) => {
warn!("Failed to parse extension handshake: {}", e);
None
}
}
} else if let Some(peer_id) = registry.peer_ut_metadata_id() {
if ext_id == peer_id {
match UtMetadataMessage::from_payload(payload) {
Ok(msg) => match msg {
UtMetadataMessage::Request { piece } => {
trace!("ut_metadata Request for piece {}", piece);
Some(ExtensionUpdate::MetadataRequest { piece })
}
UtMetadataMessage::Data {
piece,
total_size,
data,
} => {
trace!(
"ut_metadata Data piece {} (total_size={}, data_len={})",
piece,
total_size,
data.len()
);
Some(ExtensionUpdate::MetadataPiece {
piece,
total_size,
data,
})
}
UtMetadataMessage::Reject { piece } => {
trace!("ut_metadata Reject for piece {}", piece);
Some(ExtensionUpdate::MetadataReject { piece })
}
},
Err(e) => {
warn!("Failed to parse ut_metadata payload: {}", e);
None
}
}
} else {
try_dispatch_pex(registry, ext_id, payload)
}
} else {
try_dispatch_pex(registry, ext_id, payload)
}
}
fn try_dispatch_pex(
registry: &ExtensionRegistry,
ext_id: u8,
payload: &[u8],
) -> Option<ExtensionUpdate> {
let peer_pex_id = registry.peer_ut_pex_id()?;
if ext_id != peer_pex_id {
if let Some(name) = registry.extension_name_for_id(ext_id) {
warn!(
"Received unhandled extension message: {:?} (ext_id={})",
String::from_utf8_lossy(name),
ext_id
);
} else {
warn!("Received unknown extension message with ext_id={}", ext_id);
}
return None;
}
match UtPexMessage::from_payload(payload) {
Ok(msg) => {
trace!(
"ut_pex: {} IPv4 added, {} IPv6 added, {} IPv4 dropped, {} IPv6 dropped",
msg.added.len(),
msg.added6.len(),
msg.dropped.len(),
msg.dropped6.len()
);
Some(ExtensionUpdate::PeerExchange {
added_v4: msg.added,
added_v6: msg.added6,
dropped_v4: msg.dropped,
dropped_v6: msg.dropped6,
})
}
Err(e) => {
warn!("Failed to parse ut_pex payload: {}", e);
None
}
}
}