use std::collections::{HashMap, HashSet};
use std::net::SocketAddr;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, Instant};
use bytes::Bytes;
use tokio::sync::{mpsc, RwLock};
use tracing::{debug, info, warn};
use crate::inbound::InboundHandler;
use crate::config::ResilienceConfig;
use crate::error::{Error, Result};
use crate::peer::{PeerConnection, PeerMessage, UploadSlotManager};
use crate::peer::{
build_swarm_extension_handshake, parse_extension_handshake, ExtensionMessage, ExtensionMessageId,
MetadataMessage, PexDelta,
};
use crate::piece::{verify_piece, PieceAssembly};
use crate::security::{validate_piece_block_write, validate_upload_request};
use crate::session::Session;
use crate::wire::validate_bitfield;
pub const MAX_PIPELINE: usize = 5;
const MAIN_LOOP_POLL: Duration = Duration::from_millis(250);
const PEER_KEEPALIVE_INTERVAL: Duration = Duration::from_secs(60);
struct AbortOnDrop(tokio::task::JoinHandle<()>);
impl Drop for AbortOnDrop {
fn drop(&mut self) {
self.0.abort();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DownloadProgress {
pub pieces_complete: u32,
pub piece_count: u32,
pub bytes_downloaded: u64,
}
pub struct DownloadState {
pub session: Arc<Session>,
assemblies: RwLock<HashMap<u32, PieceAssembly>>,
completed: RwLock<HashSet<u32>>,
bytes_downloaded: AtomicU64,
last_progress: RwLock<Instant>,
last_active_peers: RwLock<Instant>,
}
impl DownloadState {
pub async fn new(session: Arc<Session>) -> Self {
let completed = session.picker().read().await.have_pieces();
let resumed = session.resumed_bytes();
Self {
session,
assemblies: RwLock::new(HashMap::new()),
completed: RwLock::new(completed),
bytes_downloaded: AtomicU64::new(resumed),
last_progress: RwLock::new(Instant::now()),
last_active_peers: RwLock::new(Instant::now()),
}
}
pub async fn touch_progress(&self) {
*self.last_progress.write().await = Instant::now();
let _ = self.progress().await;
}
pub async fn touch_active_peers(&self) {
*self.last_active_peers.write().await = Instant::now();
}
pub async fn heal_reason(&self, active_peers: usize, cfg: &ResilienceConfig) -> Option<&'static str> {
if self.is_done().await {
return None;
}
let now = Instant::now();
if active_peers == 0 {
let last_active = *self.last_active_peers.read().await;
if now.duration_since(last_active) >= Duration::from_secs(cfg.stale_peer_secs) {
return Some("no active peers");
}
}
let last_progress = *self.last_progress.read().await;
if now.duration_since(last_progress) >= Duration::from_secs(cfg.stalled_download_secs) {
return Some("download stalled");
}
None
}
pub async fn is_done(&self) -> bool {
self.session.picker().read().await.is_complete()
}
pub async fn progress(&self) -> DownloadProgress {
let progress = DownloadProgress {
pieces_complete: self.completed.read().await.len() as u32,
piece_count: self.session.info().piece_count(),
bytes_downloaded: self.bytes_downloaded.load(Ordering::Relaxed),
};
self.session.publish_progress_snapshot(progress);
progress
}
pub async fn can_serve_piece(&self, index: u32) -> bool {
self.completed.read().await.contains(&index)
}
pub async fn verified_bitfield(&self) -> Result<Vec<u8>> {
let count = self.session.info().piece_count();
let mut bitfield = vec![0u8; count.div_ceil(8) as usize];
let completed = self.completed.read().await;
for index in completed.iter() {
let byte = (*index / 8) as usize;
let bit = 7 - (*index % 8);
bitfield[byte] |= 1 << bit;
}
Ok(bitfield)
}
}
struct PeerNotify {
have_tx: mpsc::UnboundedSender<u32>,
}
pub struct SwarmCoordinator {
session: Arc<Session>,
state: Arc<DownloadState>,
max_peers: usize,
upload_slots: Arc<UploadSlotManager>,
active: RwLock<HashSet<SocketAddr>>,
notify: RwLock<HashMap<SocketAddr, PeerNotify>>,
}
impl SwarmCoordinator {
pub fn new(session: Arc<Session>, state: Arc<DownloadState>) -> Self {
Self {
max_peers: session.config().max_peers.max(1),
upload_slots: Arc::new(UploadSlotManager::new(session.config().max_upload_slots)),
session,
state,
active: RwLock::new(HashSet::new()),
notify: RwLock::new(HashMap::new()),
}
}
async fn active_count(&self) -> usize {
self.active.read().await.len()
}
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);
self.notify.write().await.remove(&addr);
}
async fn register_notify(&self, addr: SocketAddr, have_tx: mpsc::UnboundedSender<u32>) {
self.notify
.write()
.await
.insert(addr, PeerNotify { have_tx });
}
pub async fn broadcast_have(&self, index: u32) {
let notify = self.notify.read().await;
for handle in notify.values() {
let _ = handle.have_tx.send(index);
}
}
pub async fn persist_checkpoint(&self) -> Result<()> {
let completed = self.state.completed.read().await.clone();
let bytes = self.state.bytes_downloaded.load(Ordering::Relaxed);
self.session.save_checkpoint(bytes, &completed).await
}
pub fn spawn_outbound(self: &Arc<Self>, addr: SocketAddr) {
let coordinator = Arc::clone(self);
tokio::spawn(async move {
let is_static = coordinator.session.is_static_peer(addr).await;
if !is_static {
let gate = crate::net::DialGate::from_block_private(
coordinator.session.config().tracker_block_private,
);
if gate.ensure_dialable(addr).is_err() {
return;
}
}
if !coordinator
.session
.peer_ledger()
.read()
.await
.is_available(addr, coordinator.session.resilience())
{
return;
}
if !coordinator.try_admit(addr).await {
return;
}
let result = async {
let conn = connect_swarm_peer(&coordinator.session, addr).await?;
coordinator.state.touch_active_peers().await;
swarm_peer_session(conn, coordinator.state.clone(), coordinator.clone()).await
}
.await;
coordinator.release(addr).await;
match result {
Ok(()) => coordinator.session.record_peer_success(addr),
Err(err) => {
debug!(%err, %addr, "swarm peer session ended");
coordinator.session.record_peer_failure(addr);
coordinator
.session
.client()
.signal_peer_broken(addr, coordinator.session.info_hash());
}
}
});
}
pub fn spawn_connected(self: &Arc<Self>, conn: PeerConnection) {
let addr = conn.addr;
let coordinator = Arc::clone(self);
tokio::spawn(async move {
if !coordinator.try_admit(addr).await {
return;
}
let result = async {
coordinator.state.touch_active_peers().await;
coordinator.session.record_peer_success(addr);
swarm_peer_session(conn, coordinator.state.clone(), coordinator.clone()).await
}
.await;
coordinator.release(addr).await;
if let Err(err) = result {
debug!(%err, %addr, "secure swarm peer session ended");
coordinator.session.record_peer_failure(addr);
coordinator
.session
.client()
.signal_peer_broken(addr, coordinator.session.info_hash());
}
});
}
pub fn as_handler(self: &Arc<Self>) -> Arc<dyn InboundHandler> {
Arc::new(SwarmInboundHandler(Arc::clone(self)))
}
pub fn spawn_healer(self: &Arc<Self>) -> tokio::task::JoinHandle<()> {
let coordinator = Arc::clone(self);
tokio::spawn(async move {
let cfg = *coordinator.session.resilience();
let mut interval = tokio::time::interval(cfg.heal_interval());
interval.tick().await;
let mut last_checkpoint = Instant::now();
loop {
interval.tick().await;
if coordinator.state.is_done().await {
break;
}
let active = coordinator.active_count().await;
if active > 0 {
coordinator.state.touch_active_peers().await;
}
if let Some(reason) = coordinator.state.heal_reason(active, &cfg).await {
info!(reason, hash = %coordinator.session.info_hash().to_hex(), "self-heal");
coordinator.session.heal_discovery().await;
coordinator.replenish_peers(true).await;
} else if active < coordinator.max_peers {
coordinator.replenish_peers(false).await;
}
if last_checkpoint.elapsed() >= cfg.checkpoint_interval() {
if let Err(err) = coordinator.persist_checkpoint().await {
warn!(%err, "checkpoint save failed");
}
last_checkpoint = Instant::now();
}
}
})
}
pub async fn replenish_peers(self: &Arc<Self>, include_discovery: bool) {
if self.active_count().await >= self.max_peers {
return;
}
let active = self.active.read().await.clone();
let mut targets = self
.session
.peer_ledger()
.read()
.await
.reconnect_candidates(&active);
if include_discovery {
if let Ok(discovered) = self.session.discover_peers().await {
let mut seen: HashSet<SocketAddr> = targets.iter().copied().collect();
seen.extend(active.iter().copied());
for addr in discovered {
if !seen.insert(addr) {
continue;
}
targets.push(addr);
}
}
}
for addr in targets {
if self.active_count().await >= self.max_peers {
break;
}
if active.contains(&addr) {
continue;
}
if !self
.session
.peer_ledger()
.read()
.await
.is_available(addr, self.session.resilience())
{
continue;
}
self.spawn_outbound(addr);
}
}
pub fn spawn_upload_rotator(self: &Arc<Self>) -> Option<tokio::task::JoinHandle<()>> {
self.upload_slots
.spawn_rotator(self.session.config().upload_rotate_secs)
}
pub async fn ingest_pex(self: &Arc<Self>, source: SocketAddr, delta: &PexDelta) {
if !self.session.config().pex_enabled || self.session.info().private {
return;
}
let block_private = self.session.config().tracker_block_private;
let added = crate::tracker::filter_peers_for_dial(delta.added.iter().copied(), block_private);
if !added.is_empty() {
self.session
.peer_ledger()
.write()
.await
.note_discovered(&added);
}
for peer in &added {
if *peer == source {
continue;
}
if self.active.read().await.contains(peer) {
continue;
}
if self.active_count().await >= self.max_peers {
break;
}
if !self
.session
.peer_ledger()
.read()
.await
.is_available(*peer, self.session.resilience())
{
continue;
}
self.spawn_outbound(*peer);
}
}
pub async fn pex_candidates(self: &Arc<Self>, exclude: SocketAddr) -> PexDelta {
let active = self.active.read().await.clone();
let added: Vec<SocketAddr> = self
.session
.peer_ledger()
.read()
.await
.reconnect_candidates(&active)
.into_iter()
.filter(|addr| *addr != exclude)
.take(50)
.collect();
PexDelta {
added,
dropped: Vec::new(),
}
}
pub fn spawn_web_seed_fetcher(self: &Arc<Self>) -> Option<tokio::task::JoinHandle<()>> {
if !self.session.config().web_seed_enabled || self.session.web_seeds().is_empty() {
return None;
}
let coordinator = Arc::clone(self);
Some(tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_secs(10));
interval.tick().await;
loop {
interval.tick().await;
if coordinator.state.is_done().await {
break;
}
let piece_count = coordinator.session.info().piece_count();
let missing: Vec<u32> = {
let picker_arc = coordinator.session.picker();
let picker = picker_arc.read().await;
let have = picker.have_pieces();
(0..piece_count)
.filter(|i| picker.is_wanted(*i) && !have.contains(i))
.collect()
};
for piece in missing {
if coordinator.state.is_done().await {
break;
}
if coordinator.state.completed.read().await.contains(&piece) {
continue;
}
match try_fetch_web_seed_piece(&coordinator.state, &coordinator, piece).await {
Ok(true) => info!(piece, "web seed piece verified"),
Ok(false) => {}
Err(err) => debug!(%err, piece, "web seed ingest failed"),
}
}
}
}))
}
pub async fn initial_peers(self: &Arc<Self>) {
self.replenish_peers(true).await;
if self.active_count().await == 0 {
warn!("no peers connected initially; self-healer will retry");
}
}
}
struct SwarmInboundHandler(Arc<SwarmCoordinator>);
impl InboundHandler for SwarmInboundHandler {
fn spawn_secure_connected(&self, conn: PeerConnection) {
self.0.spawn_connected(conn);
}
}
pub async fn run_download(session: Arc<Session>) -> Result<DownloadProgress> {
let piece_count = session.info().piece_count();
if session.picker().read().await.is_complete() {
session.announce_started().await;
session.announce_completed().await;
let completed = session.picker().read().await.complete_count() as u32;
return Ok(DownloadProgress {
pieces_complete: completed,
piece_count,
bytes_downloaded: session.resumed_bytes(),
});
}
session.announce_started().await;
let state = Arc::new(DownloadState::new(Arc::clone(&session)).await);
let coordinator = Arc::new(SwarmCoordinator::new(session.clone(), Arc::clone(&state)));
let hash = session.info_hash();
session
.client()
.register_inbound(hash, coordinator.as_handler())
.await;
let _healer = AbortOnDrop(coordinator.spawn_healer());
let _upload_rotator = coordinator.spawn_upload_rotator().map(AbortOnDrop);
let _web_seeds = coordinator.spawn_web_seed_fetcher().map(AbortOnDrop);
coordinator.initial_peers().await;
while !state.is_done().await {
if session.is_stop_requested() {
drop(_healer);
drop(_upload_rotator);
drop(_web_seeds);
session.client().unregister_inbound(hash).await;
session.announce_stopped().await;
return Err(Error::Session("session stopped".into()));
}
if coordinator.active_count().await == 0 {
coordinator.replenish_peers(false).await;
} else {
state.touch_active_peers().await;
}
tokio::time::sleep(MAIN_LOOP_POLL).await;
}
drop(_healer);
drop(_upload_rotator);
drop(_web_seeds);
session.client().unregister_inbound(hash).await;
session.announce_stopped().await;
tokio::time::sleep(Duration::from_millis(500)).await;
session.store().flush_all().await?;
coordinator.persist_checkpoint().await?;
let progress = state.progress().await;
if !state.is_done().await {
return Err(Error::Session(format!(
"download incomplete: {}/{} pieces verified (wanted set not complete)",
progress.pieces_complete, progress.piece_count
)));
}
session.announce_completed().await;
Ok(progress)
}
async fn connect_swarm_peer(session: &Session, addr: SocketAddr) -> Result<PeerConnection> {
let hash = session.info_hash();
if session.is_static_peer(addr).await {
session
.client()
.dial_torrent_peer_host(addr, hash, true)
.await
} else {
session.client().dial_torrent_peer(addr, hash, true).await
}
}
async fn swarm_peer_session(
mut conn: PeerConnection,
state: Arc<DownloadState>,
coordinator: Arc<SwarmCoordinator>,
) -> Result<()> {
let addr = conn.addr;
let (have_tx, mut have_rx) = mpsc::unbounded_channel();
coordinator.register_notify(addr, have_tx).await;
let (slot_tx, mut slot_rx) = mpsc::unbounded_channel();
coordinator.upload_slots.register(addr, slot_tx).await;
let mut ut_pex_id: Option<u8> = None;
let mut ut_metadata_id: Option<u8> = None;
let end_game_threshold = state.session.config().end_game_threshold;
let metadata_size = state.session.metadata_size();
if conn.extensions {
conn.send_extended(
0,
&build_swarm_extension_handshake(metadata_size),
)
.await?;
}
let bitfield = state.verified_bitfield().await?;
if bitfield.iter().any(|&byte| byte != 0) {
conn.send(&PeerMessage::Bitfield(bitfield)).await?;
}
conn.send(&PeerMessage::Interested).await?;
let mut unchoked = false;
let mut peer_interested = false;
let mut in_flight = 0usize;
let mut current_piece: Option<u32> = None;
let mut suggested_piece: Option<u32> = None;
let piece_count = state.session.info().piece_count();
let mut peer_bits = vec![0u8; piece_count.div_ceil(8) as usize];
let mut keepalive =
tokio::time::interval(PEER_KEEPALIVE_INTERVAL);
keepalive.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
keepalive.tick().await;
let session_result = async {
loop {
if state.is_done().await {
break;
}
while unchoked && in_flight < MAX_PIPELINE && !state.is_done().await {
if current_piece.is_none() {
current_piece = {
let picker_arc = state.session.picker();
if let Some(suggest) = suggested_piece.take() {
let mut picker = picker_arc.write().await;
if picker.request_piece(suggest) {
Some(suggest)
} else {
picker.next_piece()
}
} else if picker_arc.read().await.in_end_game(end_game_threshold) {
picker_arc.write().await.next_piece_endgame()
} else {
picker_arc.write().await.next_piece()
}
};
}
let Some(piece) = current_piece else {
break;
};
let (begin, length) = {
let mut assemblies = state.assemblies.write().await;
let assembly = assemblies.entry(piece).or_insert_with(|| {
PieceAssembly::new(
state.session.info().piece_size(piece),
state.session.config().block_size,
)
});
let Some(begin) = assembly.next_block() else {
current_piece = None;
state.session.picker().write().await.release_piece(piece);
continue;
};
let length = assembly.block_length(begin);
(begin, length)
};
conn.send(&PeerMessage::Request {
index: piece,
begin,
length,
})
.await?;
in_flight += 1;
}
tokio::select! {
biased;
_ = keepalive.tick() => {
conn.send(&PeerMessage::KeepAlive).await?;
}
grant = slot_rx.recv() => {
let Some(unchoke) = grant else {
break;
};
if unchoke {
conn.send(&PeerMessage::Unchoke).await?;
} else {
conn.send(&PeerMessage::Choke).await?;
}
}
message = conn.recv() => {
match message? {
PeerMessage::Unchoke => unchoked = true,
PeerMessage::Choke => {
unchoked = false;
in_flight = 0;
let _ = current_piece.take();
}
PeerMessage::Bitfield(bitfield) => {
validate_bitfield(&bitfield, state.session.info().piece_count())?;
state.session.picker().write().await.remove_bitfield(&peer_bits);
peer_bits = bitfield.clone();
state.session.picker().write().await.note_bitfield(&bitfield);
}
PeerMessage::Have(index)
if index < state.session.info().piece_count() =>
{
let byte = (index / 8) as usize;
let bit = 7 - (index % 8) as u8;
if peer_bits.get(byte).is_some_and(|b| (b >> bit) & 1 == 0) {
peer_bits[byte] |= 1 << bit;
state.session.picker().write().await.note_availability(index);
}
}
PeerMessage::HaveAll if conn.fast => {
state.session.picker().write().await.remove_bitfield(&peer_bits);
peer_bits.fill(0xff);
let spare = (8 - (piece_count % 8) as u8) % 8;
if spare > 0 {
if let Some(last) = peer_bits.last_mut() {
*last &= !((1u8 << spare) - 1);
}
}
state.session.picker().write().await.note_bitfield(&peer_bits);
}
PeerMessage::HaveNone if conn.fast => {}
PeerMessage::SuggestPiece(index)
if conn.fast && index < state.session.info().piece_count() =>
{
suggested_piece = Some(index);
}
PeerMessage::RejectRequest { index, begin, length: _ } if conn.fast => {
in_flight = in_flight.saturating_sub(1);
if current_piece == Some(index) {
current_piece = None;
}
state.session.picker().write().await.release_piece(index);
let _ = begin;
}
PeerMessage::AllowedFast(_) if conn.fast => {}
PeerMessage::Port(_) => {}
PeerMessage::Extended { id, payload } => {
if id == 0 {
if let Some((_, ExtensionMessage::Handshake(body))) =
ExtensionMessage::decode(&payload, id, None, None)?
{
let (_, meta_id, pex_id) = parse_extension_handshake(&body)?;
ut_metadata_id = meta_id;
ut_pex_id = pex_id;
if ut_pex_id.is_some()
&& state.session.config().pex_enabled
&& !state.session.info().private
{
let delta = coordinator.pex_candidates(addr).await;
if !delta.added.is_empty() {
if let Some(pex_id) = ut_pex_id {
conn.send_extended(
pex_id,
&ExtensionMessage::Pex(delta),
).await?;
}
}
}
}
} else if ut_metadata_id == Some(id)
|| id == ExtensionMessageId::Metadata as u8
{
if let Some((_, ExtensionMessage::Metadata(meta))) =
ExtensionMessage::decode(
&payload,
id,
Some(id),
ut_pex_id,
)?
{
match meta {
MetadataMessage::Request { piece } => {
let bytes = state.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?;
}
}
MetadataMessage::Data { .. }
| MetadataMessage::Reject { .. } => {}
}
}
} else if ut_pex_id == Some(id) {
if let Some((_, ExtensionMessage::Pex(delta))) =
ExtensionMessage::decode(&payload, id, None, ut_pex_id)?
{
coordinator.ingest_pex(addr, &delta).await;
}
}
}
PeerMessage::Interested => {
peer_interested = true;
if state.verified_bitfield().await?.iter().any(|&byte| byte != 0) {
coordinator.upload_slots.on_interested(addr).await;
}
}
PeerMessage::NotInterested => {
peer_interested = false;
coordinator.upload_slots.on_not_interested(addr).await;
}
PeerMessage::Request { index, begin, length }
if peer_interested
&& coordinator.upload_slots.is_unchoked(addr).await
&& state.can_serve_piece(index).await =>
{
validate_upload_request(
state.session.info(),
index,
begin,
length,
state.session.config().block_size,
)?;
let data = state
.session
.store()
.read_block(index, begin, length as usize)
.await?;
state
.session
.client()
.upload_limiter()
.consume(data.len() as u64)
.await;
state.session.record_uploaded(data.len() as u64);
conn.send(&PeerMessage::Piece {
index,
begin,
data: data.to_vec(),
})
.await?;
}
PeerMessage::HashRequest(req) => {
if !coordinator.upload_slots.is_unchoked(addr).await {
continue;
}
let answer = crate::peer::HashRequestAnswer::resolve(
state.session.info(),
req,
);
let bytes = answer.upload_bytes();
state
.session
.client()
.upload_limiter()
.consume(bytes)
.await;
state.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::Hashes(_) | PeerMessage::HashReject(_) => {
}
PeerMessage::Piece { index, begin, data } => {
in_flight = in_flight.saturating_sub(1);
validate_piece_block_write(
state.session.info(),
index,
begin,
data.len(),
state.session.config().block_size,
)?;
let block_len = data.len() as u64;
state
.session
.client()
.download_limiter()
.consume(block_len)
.await;
state.session.record_peer_success(addr);
state
.session
.store()
.write_block(index, begin, Bytes::from(data))
.await?;
let complete = {
let mut assemblies = state.assemblies.write().await;
let assembly = assemblies.entry(index).or_insert_with(|| {
PieceAssembly::new(
state.session.info().piece_size(index),
state.session.config().block_size,
)
});
let newly = assembly.mark_block(begin);
if newly {
state.bytes_downloaded.fetch_add(block_len, Ordering::Relaxed);
state.session.record_downloaded(block_len);
}
assembly.is_complete()
};
if complete {
match finalize_piece(&state, &coordinator, index).await {
Ok(true) => {
current_piece = None;
if state.is_done().await {
break;
}
}
Ok(false) => {
current_piece = None;
state.session.picker().write().await.release_piece(index);
}
Err(err) => {
warn!(%err, piece = index, "piece finalize failed");
state.assemblies.write().await.remove(&index);
current_piece = None;
state.session.picker().write().await.release_piece(index);
}
}
}
}
PeerMessage::KeepAlive => {
state.session.record_peer_success(addr);
}
_ => {}
}
}
have = have_rx.recv() => {
if let Some(index) = have {
conn.send(&PeerMessage::Have(index)).await?;
} else {
break;
}
}
}
}
Ok(())
}
.await;
state.session.picker().write().await.remove_bitfield(&peer_bits);
session_result
}
async fn try_fetch_web_seed_piece(
state: &DownloadState,
coordinator: &SwarmCoordinator,
piece: u32,
) -> Result<bool> {
let session = Arc::clone(&state.session);
let Some(data) = crate::webseed::try_web_seed_piece(session, piece).await else {
return Ok(false);
};
let block_size = state.session.config().block_size;
let mut offset = 0u32;
for chunk in data.chunks(block_size as usize) {
state
.session
.store()
.write_block(piece, offset, Bytes::copy_from_slice(chunk))
.await?;
offset = offset.saturating_add(block_size);
}
finalize_piece(state, coordinator, piece).await
}
async fn finalize_piece(
state: &DownloadState,
coordinator: &SwarmCoordinator,
index: u32,
) -> Result<bool> {
let piece_data = assemble_piece(state, index).await?;
if !verify_piece(state.session.info(), index, &piece_data)? {
warn!(piece = index, "piece hash mismatch");
state.assemblies.write().await.remove(&index);
state.session.picker().write().await.release_piece(index);
return Ok(false);
}
state.completed.write().await.insert(index);
state.assemblies.write().await.remove(&index);
state.session.picker().write().await.mark_have(index);
state.touch_progress().await;
coordinator.broadcast_have(index).await;
if let Err(err) = state
.session
.store()
.store_piece_parity(index, &piece_data)
.await
{
warn!(%err, piece = index, "failed to store piece parity");
}
let done = state.completed.read().await.len();
info!(
piece = index,
done,
total = state.session.info().piece_count(),
"piece verified"
);
Ok(true)
}
async fn assemble_piece(state: &DownloadState, piece: u32) -> Result<Vec<u8>> {
let piece_size = state.session.info().piece_size(piece) as usize;
let block_size = state.session.config().block_size;
let mut out = Vec::with_capacity(piece_size);
let mut offset = 0u32;
while out.len() < piece_size {
let remaining = piece_size - out.len();
let len = remaining.min(block_size as usize);
let block = state.session.store().read_block(piece, offset, len).await?;
out.extend_from_slice(&block);
offset = offset.saturating_add(block_size);
}
Ok(out)
}
pub async fn build_seed_bitfield(session: &Session) -> Result<Vec<u8>> {
let count = session.info().piece_count();
let mut bitfield = vec![0u8; count.div_ceil(8) as usize];
for index in 0..count {
if seed_piece_available(session, index).await? {
let byte = (index / 8) as usize;
let bit = 7 - (index % 8);
bitfield[byte] |= 1 << bit;
}
}
Ok(bitfield)
}
pub async fn seed_piece_available(session: &Session, index: u32) -> Result<bool> {
if session.config().seed_require_verified {
let data = session.store().read_piece(index).await?;
return crate::piece::verify_piece(session.info(), index, &data);
}
let begin = 0;
let len = session
.info()
.piece_size(index)
.min(session.config().block_size) as usize;
Ok(session.store().read_block(index, begin, len).await.is_ok())
}