torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
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 {
        // BEP 6 HaveNone only when Fast Extension negotiated.
        if conn.fast {
            conn.send(&PeerMessage::HaveNone).await?;
        } else {
            // Empty bitfield: no pieces advertised yet (super-seed without Fast).
            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) => {
                        // Same upload policy as Piece: only serve while unchoked.
                        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(())
}