use std::collections::HashSet;
use std::time::Instant;
use tracing::{debug, info, trace, warn};
use super::super::types::PeerKey;
use crate::engine::bt_download_command::BtDownloadCommand;
use crate::engine::bt_peer_connection::BtPeerConn;
use crate::engine::bt_peer_interaction::{BtPeerCryptoPolicy, BtPeerInteraction};
use crate::engine::extension_registry::ExtensionUpdate;
use crate::error::{Aria2Error, RecoverableError, Result};
use crate::util::rwlock_ext::RwLockRecover;
use aria2_protocol::bittorrent::extension::pex::PexHandler;
use aria2_protocol::bittorrent::message::serializer::serialize_extended;
use aria2_protocol::bittorrent::peer::connection::PeerAddr;
impl BtDownloadCommand {
pub fn build_pex_extended_message(
&mut self,
remote_peer_addr: &PeerAddr,
remote_ut_pex_id: u8,
) -> Option<Vec<u8>> {
if self.is_private {
return None;
}
if !self.should_send_pex() {
return None;
}
if self.pex_known_peers.is_empty() {
trace!("[PEX] No known peers to exchange");
return None;
}
let pex_bencode = PexHandler::build_pex_added(
&self.pex_known_peers,
remote_peer_addr,
PexHandler::DEFAULT_MAX_PEERS,
);
let payload = pex_bencode.encode();
let wire_bytes = serialize_extended(remote_ut_pex_id, payload);
self.update_pex_last_send();
debug!(
size = wire_bytes.len(),
known_peers = self.pex_known_peers.len(),
"[PEX] Built Extended message (remote ext_id={})",
remote_ut_pex_id
);
Some(wire_bytes)
}
pub fn handle_incoming_pex(
&mut self,
pex_data: &[u8],
local_addr: &PeerAddr,
) -> Result<(Vec<PeerAddr>, Vec<PeerAddr>)> {
if self.is_private {
debug!("[PEX] Ignoring incoming PEX for private torrent (BEP 0027)");
return Ok((Vec::new(), Vec::new()));
}
match PexHandler::process_received_pex(pex_data, local_addr) {
Ok((added, dropped)) => {
if !added.is_empty() {
info!(count = added.len(), "[PEX] Discovered new peers from PEX");
for peer in &added {
self.add_pex_peer(peer.clone());
}
}
if !dropped.is_empty() {
debug!(count = dropped.len(), "[PEX] Peers to drop from PEX");
}
Ok((added, dropped))
}
Err(e) => {
warn!(error = %e, "[PEX] Failed to process incoming PEX message");
Err(Aria2Error::Recoverable(
RecoverableError::TemporaryNetworkFailure {
message: format!("PEX processing failed: {}", e),
},
))
}
}
}
pub fn process_pex_extension_update(
&mut self,
update: &ExtensionUpdate,
_local_addr: &PeerAddr,
) -> Vec<PeerAddr> {
if self.is_private {
return Vec::new();
}
let (added_v4, added_v6, dropped_v4, dropped_v6) = match update {
ExtensionUpdate::PeerExchange {
added_v4,
added_v6,
dropped_v4,
dropped_v6,
} => (added_v4, added_v6, dropped_v4, dropped_v6),
_ => return Vec::new(),
};
let mut new_peers = Vec::new();
for compact in added_v4 {
let ip = std::net::Ipv4Addr::from(*compact.ip());
let addr = PeerAddr::new(&ip.to_string(), compact.port());
if !self.pex_known_peers.contains(&addr) {
self.add_pex_peer(addr.clone());
new_peers.push(addr);
}
}
for compact in added_v6 {
let ip = std::net::Ipv6Addr::from(*compact.ip());
let addr = PeerAddr::new(&ip.to_string(), compact.port());
if !self.pex_known_peers.contains(&addr) {
self.add_pex_peer(addr.clone());
new_peers.push(addr);
}
}
let mut dropped_addrs = Vec::new();
for compact in dropped_v4 {
let ip = std::net::Ipv4Addr::from(*compact.ip());
let addr = PeerAddr::new(&ip.to_string(), compact.port());
dropped_addrs.push(addr);
}
for compact in dropped_v6 {
let ip = std::net::Ipv6Addr::from(*compact.ip());
let addr = PeerAddr::new(&ip.to_string(), compact.port());
dropped_addrs.push(addr);
}
if !dropped_addrs.is_empty() {
self.pex_known_peers.retain(|p| !dropped_addrs.contains(p));
debug!(
dropped = dropped_addrs.len(),
remaining = self.pex_known_peers.len(),
"[PEX] Removed dropped peers from known list"
);
}
if !new_peers.is_empty() {
info!(
new = new_peers.len(),
total = self.pex_known_peers.len(),
"[PEX] Added new peers from extension update"
);
}
new_peers
}
pub async fn connect_to_discovered_peers(
&mut self,
new_peers: &[PeerAddr],
info_hash_raw: &[u8; 20],
num_pieces: u32,
active_connections: &[BtPeerConn],
piece_length: u32,
total_size: u64,
) -> Vec<BtPeerConn> {
if self.is_private || new_peers.is_empty() {
return Vec::new();
}
let already_connected: HashSet<(String, u16)> = active_connections
.iter()
.map(|conn| (conn.ip_addr.clone(), conn.port))
.collect();
let peers_to_connect: Vec<PeerAddr> = self
.peer_coordinator
.select_candidates(new_peers, &already_connected)
.into_iter()
.filter(|peer| !self.is_peer_temporarily_rejected(&peer.ip))
.collect();
if peers_to_connect.is_empty() {
debug!("[PEX] All discovered peers already connected");
return Vec::new();
}
info!(
"[PEX] Attempting to connect to {} new peers discovered via PEX",
peers_to_connect.len()
);
let crypto_policy = {
let group = self.group.recover();
BtPeerCryptoPolicy {
require_mse: group.options().bt_require_crypto || group.options().bt_force_encrypt,
force_encryption: group.options().bt_force_encrypt,
prefer_encryption: group.effective_option_snapshot().is_some_and(|snapshot| {
snapshot
.get("bt-min-crypto-level")
.and_then(serde_json::Value::as_str)
.is_some_and(|level| level.eq_ignore_ascii_case("arc4"))
}) || group.options().bt_force_encrypt,
}
};
let mut connected = Vec::with_capacity(peers_to_connect.len());
for peer in &peers_to_connect {
match BtPeerInteraction::connect_peer_ready(
peer,
info_hash_raw,
crypto_policy,
num_pieces,
piece_length,
total_size,
)
.await
{
Ok(conn) => {
debug!("[PEX] Connected to {}:{}", peer.ip, peer.port);
connected.push(conn);
}
Err(e) => {
debug!(
"[PEX] Failed to connect to {}:{}: {}",
peer.ip, peer.port, e
);
}
}
}
connected
}
}
pub(super) async fn send_periodic_pex(
cmd: &mut BtDownloadCommand,
active_connections: &mut [BtPeerConn],
pex_enabled_peers: &HashSet<PeerKey>,
last_pex_send: &mut Instant,
pex_send_interval_secs: u64,
) {
if last_pex_send.elapsed().as_secs() < pex_send_interval_secs
|| pex_enabled_peers.is_empty()
|| cmd.pex_known_peers.is_empty()
{
return;
}
*last_pex_send = Instant::now();
let pex_peers_count = cmd.pex_known_peers.len();
let mut sent_count = 0usize;
for &peer_key in pex_enabled_peers.iter() {
if let Some(conn) = active_connections
.iter_mut()
.find(|conn| PeerKey::from_peer(&conn.ip_addr, conn.port) == Some(peer_key))
{
let remote_addr = PeerAddr::new(&conn.ip_addr, conn.port);
let Some(remote_ut_pex_id) = conn.peer_extension_id("ut_pex") else {
trace!(
"[PEX] Skipping peer {}: ut_pex was not negotiated",
peer_key.address()
);
continue;
};
if let Some(wire_bytes) = cmd.build_pex_extended_message(&remote_addr, remote_ut_pex_id)
{
conn.queue_message(wire_bytes);
if let Err(e) = conn.flush_send_buffer().await {
warn!(
"[PEX] Failed to flush send buffer for peer {} ({}:{}): {}",
peer_key.address(),
conn.ip_addr,
conn.port,
e
);
continue;
}
sent_count += 1;
trace!(
"[PEX] Sent PEX to peer {} ({}:{}) with {} known peers",
peer_key.address(),
conn.ip_addr,
conn.port,
pex_peers_count
);
}
}
}
if sent_count > 0 {
info!(
"[PEX] Periodic PEX exchange: sent to {}/{} enabled peers, {} known peers",
sent_count,
pex_enabled_peers.len(),
pex_peers_count
);
}
}
#[allow(dead_code)] pub(super) fn process_incoming_pex_update(
cmd: &mut BtDownloadCommand,
update: &ExtensionUpdate,
local_addr: &PeerAddr,
) -> Vec<PeerAddr> {
cmd.process_pex_extension_update(update, local_addr)
}