Struct BtPeerConn 

pub struct BtPeerConn {
    pub allowed_fast: HashSet<u32>,
    pub connection_type: ConnectionType,
    /* private fields */
}

Peer connection abstraction that supports both plain and encrypted (MSE) connections.

This mirrors the original aria2 C++ architecture where connection management is separated from the download command logic (see BtRuntime in original). Now also supports uTP (UDP-based) connections per BEP 29.

Fields

allowed_fast: HashSet<u32>

Set of piece indices for which the peer has sent an AllowedFast message. Pieces in this set can be requested even when the peer is choked.

connection_type: ConnectionType

Connection type (TCP or uTP)

Implementations

impl BtPeerConn

pub async fn connect_mse( addr: &PeerAddr, info_hash: &[u8; 20], require_encryption: bool, ) -> Result<Self>

Connect via MSE (Message Stream Encryption) over TCP

pub async fn connect_plain( addr: &PeerAddr, info_hash: &[u8; 20], ) -> Result<Self>

Connect via plain TCP

pub async fn connect_utp(addr: SocketAddr, info_hash: &[u8; 20]) -> Result<Self>

Connect via uTP (Micro Transport Protocol)

uTP is a UDP-based transport protocol that provides:

• Reliable, ordered delivery
• LEDBAT congestion control (low priority, background traffic)
• Better performance on congested networks
• NAT traversal benefits

pub fn from_utp_socket( socket: Arc<Mutex<UtpSocket>>, conn_id: u16, info_hash: &[u8; 20], ) -> Self

Create a uTP connection from an existing socket

Used when accepting incoming uTP connections

pub fn connection_type(&self) -> ConnectionType

Get the connection type

pub fn is_utp(&self) -> bool

Check if this is a uTP connection

pub fn add_allowed_fast(&mut self, index: u32)

Add a piece index to the AllowedFast set.

Called when an AllowedFast message is received from this peer. Pieces in the allowed_fast set can be requested even when the peer is choked (BEP 6 / Fast Extension).

pub fn is_allowed_fast(&self, index: u32) -> bool

Check whether a piece index is in the AllowedFast set.

Returns true if the peer has granted fast access to this piece, meaning a Request can be sent even while the peer is choked.

pub fn allowed_fast_set(&self) -> &HashSet<u32>

Get a reference to the full AllowedFast set

Returns all piece indices that this peer has allowed us to request via BEP 6 Fast Extension, even when choked.

pub async fn send_unchoke(&mut self) -> Result<()>

pub async fn send_choke(&mut self) -> Result<()>

pub async fn send_interested(&mut self) -> Result<()>

pub async fn send_not_interested(&mut self) -> Result<()>

pub async fn send_have(&mut self, piece_index: u32) -> Result<()>

pub async fn send_request(&mut self, req: PieceBlockRequest) -> Result<()>

pub async fn send_cancel(&mut self, req: &PieceBlockRequest) -> Result<()>

pub async fn send_bitfield(&mut self, bitfield: Vec<u8>) -> Result<()>

pub async fn read_message(&mut self) -> Result<Option<BtMessage>>

pub fn is_connected(&self) -> bool

pub fn is_encrypted(&self) -> bool