use std::collections::HashSet;
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::sync::{mpsc, RwLock};
use tracing::debug;
use crate::inbound::InboundHandler;
use crate::peer::{
build_swarm_extension_handshake, parse_extension_handshake, ExtensionMessage,
ExtensionMessageId, MetadataMessage, PeerConnection, PeerMessage, UploadSlotManager,
};
use crate::security::validate_upload_request;
use crate::session::{build_seed_bitfield, seed_piece_available, Session};
pub struct SeedInbound {
session: Arc<Session>,
max_peers: usize,
upload_slots: Arc<UploadSlotManager>,
active: RwLock<HashSet<SocketAddr>>,
}
impl SeedInbound {
pub fn new(session: Arc<Session>) -> Arc<Self> {
let cfg = session.config();
Arc::new(Self {
max_peers: cfg.max_peers.max(1),
upload_slots: Arc::new(UploadSlotManager::new(cfg.max_upload_slots)),
session,
active: RwLock::new(HashSet::new()),
})
}
pub fn as_handler(self: &Arc<Self>) -> Arc<dyn InboundHandler> {
Arc::new(SeedInboundHandler(Arc::clone(self)))
}
pub fn spawn_upload_rotator(self: &Arc<Self>) -> Option<tokio::task::JoinHandle<()>> {
self.upload_slots
.spawn_rotator(self.session.config().upload_rotate_secs)
}
async fn try_admit(&self, addr: SocketAddr) -> bool {
let mut active = self.active.write().await;
if active.len() >= self.max_peers || active.contains(&addr) {
return false;
}
active.insert(addr);
true
}
async fn release(&self, addr: SocketAddr) {
self.upload_slots.unregister(addr).await;
self.active.write().await.remove(&addr);
}
}
struct SeedInboundHandler(Arc<SeedInbound>);
impl InboundHandler for SeedInboundHandler {
fn spawn_secure_connected(&self, conn: PeerConnection) {
let inbound = Arc::clone(&self.0);
let addr = conn.addr;
tokio::spawn(async move {
if !inbound.try_admit(addr).await {
return;
}
let result =
run_seed_session(inbound.session.clone(), inbound.upload_slots.clone(), conn).await;
inbound.release(addr).await;
if let Err(err) = result {
debug!(%err, %addr, "secure seed peer session ended");
inbound
.session
.client()
.signal_peer_broken(addr, inbound.session.info_hash());
}
});
}
}
pub async fn serve_outbound_to(session: Arc<Session>, addr: SocketAddr) -> crate::error::Result<()> {
let slots = Arc::new(UploadSlotManager::new(session.config().max_upload_slots));
let hash = session.info_hash();
let conn = if session.is_static_peer(addr).await {
session
.client()
.dial_torrent_peer_host(addr, hash, false)
.await?
} else {
session
.client()
.dial_torrent_peer(addr, hash, false)
.await?
};
run_seed_session(session, slots, conn).await
}
async fn run_seed_session(
session: Arc<Session>,
upload_slots: Arc<UploadSlotManager>,
mut conn: PeerConnection,
) -> crate::error::Result<()> {
let addr = conn.addr;
let super_seed = session.config().super_seed_enabled;
let piece_count = session.info().piece_count();
let metadata_size = session.metadata_size();
let mut ut_metadata_id: Option<u8> = None;
if conn.extensions {
conn.send_extended(0, &build_swarm_extension_handshake(metadata_size))
.await?;
}
if super_seed {
if conn.fast {
conn.send(&PeerMessage::HaveNone).await?;
} else {
let empty = vec![0u8; piece_count.div_ceil(8) as usize];
conn.send(&PeerMessage::Bitfield(empty)).await?;
}
} else {
let bitfield = build_seed_bitfield(session.as_ref()).await?;
conn.send(&PeerMessage::Bitfield(bitfield)).await?;
}
let (slot_tx, mut slot_rx) = mpsc::unbounded_channel();
upload_slots.register(addr, slot_tx).await;
let mut advertised: Option<u32> = None;
loop {
tokio::select! {
biased;
grant = slot_rx.recv() => {
let Some(unchoke) = grant else {
break;
};
if unchoke {
conn.send(&PeerMessage::Unchoke).await?;
if super_seed && advertised.is_none() {
for index in 0..piece_count {
if seed_piece_available(session.as_ref(), index).await? {
conn.send(&PeerMessage::Have(index)).await?;
advertised = Some(index);
break;
}
}
}
} else {
conn.send(&PeerMessage::Choke).await?;
}
}
message = conn.recv() => {
match message? {
PeerMessage::Interested => {
upload_slots.on_interested(addr).await;
}
PeerMessage::NotInterested => {
upload_slots.on_not_interested(addr).await;
}
PeerMessage::Extended { id, payload } => {
if id == 0 {
if let Some((_, ExtensionMessage::Handshake(body))) =
ExtensionMessage::decode(&payload, id, None, None)?
{
let (_, meta_id, _) = parse_extension_handshake(&body)?;
ut_metadata_id = meta_id;
}
} else if ut_metadata_id == Some(id)
|| id == ExtensionMessageId::Metadata as u8
{
if let Some((
_,
ExtensionMessage::Metadata(MetadataMessage::Request { piece }),
)) =
ExtensionMessage::decode(&payload, id, Some(id), None)?
{
let bytes = session.info_dict_bytes();
if let Some(msg) =
crate::metadata::metadata_data_message(bytes, piece)
{
conn.send_extended(
id,
&ExtensionMessage::Metadata(msg),
)
.await?;
} else {
conn.send_extended(
id,
&ExtensionMessage::Metadata(MetadataMessage::Reject {
piece,
}),
)
.await?;
}
}
}
}
PeerMessage::Request { index, begin, length } => {
if !upload_slots.is_unchoked(addr).await {
continue;
}
if let Err(err) = validate_upload_request(
session.info(),
index,
begin,
length,
session.config().block_size,
) {
tracing::debug!(%err, %addr, "seed ignoring bad Request");
continue;
}
if super_seed && advertised != Some(index) {
continue;
}
match seed_piece_available(session.as_ref(), index).await {
Ok(true) => {}
Ok(false) => continue,
Err(err) => {
tracing::debug!(%err, %addr, "seed piece availability check failed");
continue;
}
}
let data = match session
.store()
.read_block(index, begin, length as usize)
.await
{
Ok(data) => data,
Err(err) => {
tracing::debug!(%err, %addr, "seed read_block failed");
continue;
}
};
session
.client()
.upload_limiter()
.consume(data.len() as u64)
.await;
session.record_uploaded(data.len() as u64);
conn.send(&PeerMessage::Piece {
index,
begin,
data: data.to_vec(),
})
.await?;
if super_seed && begin + length >= session.info().piece_size(index) {
advertised = None;
}
}
PeerMessage::HashRequest(req) => {
if !upload_slots.is_unchoked(addr).await {
continue;
}
let answer =
crate::peer::HashRequestAnswer::resolve(session.info(), req);
let bytes = answer.upload_bytes();
session
.client()
.upload_limiter()
.consume(bytes)
.await;
session.record_uploaded(bytes);
let msg = match answer {
crate::peer::HashRequestAnswer::Hashes(hashes) => {
PeerMessage::Hashes(hashes)
}
crate::peer::HashRequestAnswer::Reject(req) => {
PeerMessage::HashReject(req)
}
};
conn.send(&msg).await?;
}
PeerMessage::KeepAlive => {}
_ => {}
}
}
}
}
Ok(())
}