use std::net::SocketAddr;
use std::time::Duration;
use crate::error::{Error, Result};
use crate::peer::extension::ExtensionMessage;
use crate::peer::io::PeerIo;
use crate::peer::{FrameDecode, Handshake, PeerMessage};
use crate::security::MAX_PEER_READ_BUF;
use crate::torrent::InfoHash;
pub struct PeerConnection {
pub addr: SocketAddr,
pub remote_peer_id: [u8; 20],
stream: PeerIo,
read_buf: Vec<u8>,
pub extensions: bool,
pub fast: bool,
pub v2: bool,
}
impl PeerConnection {
pub async fn from_secure_initiator(
handoff: crate::secure::Handoff,
handshake: &Handshake,
) -> Result<Self> {
let addr = handoff.peer_addr;
let stream = PeerIo::from_secure(handoff.transport);
Self::from_io_initiator(addr, stream, handshake).await
}
pub async fn from_secure_acceptor(
handoff: crate::secure::Handoff,
local_peer_id: [u8; 20],
expected: Option<InfoHash>,
) -> Result<(Self, InfoHash)> {
let addr = handoff.peer_addr;
let stream = PeerIo::from_secure(handoff.transport);
Self::from_io_acceptor(addr, stream, local_peer_id, expected).await
}
pub async fn from_mse_initiator(
addr: SocketAddr,
stream: crate::mse::MseStream,
handshake: &Handshake,
) -> Result<Self> {
Self::from_io_initiator(addr, PeerIo::from_mse(stream), handshake).await
}
pub async fn from_io_initiator(
addr: SocketAddr,
mut stream: PeerIo,
handshake: &Handshake,
) -> Result<Self> {
let expected = handshake.info_hash;
stream.write_all(&encode_handshake_buf(handshake)).await?;
let mut response = [0u8; 68];
stream.read_exact(&mut response).await?;
let (remote, _) = parse_handshake_bytes(&mut response)?;
if remote.info_hash != expected {
return Err(Error::Peer("info hash mismatch".into()));
}
if remote.peer_id == handshake.peer_id {
return Err(Error::Peer(
"remote peer_id matches local peer_id (self-connection)".into(),
));
}
Ok(Self {
addr,
remote_peer_id: remote.peer_id,
stream,
read_buf: Vec::with_capacity(4096),
extensions: handshake.extensions && remote.extensions,
fast: handshake.fast && remote.fast,
v2: handshake.v2 && remote.v2,
})
}
pub async fn from_mse_acceptor(
addr: SocketAddr,
stream: crate::mse::MseStream,
local_peer_id: [u8; 20],
expected: Option<InfoHash>,
) -> Result<(Self, InfoHash)> {
Self::from_io_acceptor(addr, PeerIo::from_mse(stream), local_peer_id, expected).await
}
pub async fn from_io_acceptor(
addr: SocketAddr,
mut stream: PeerIo,
local_peer_id: [u8; 20],
expected: Option<InfoHash>,
) -> Result<(Self, InfoHash)> {
let mut peer_buf = [0u8; 68];
stream.read_exact(&mut peer_buf).await?;
let (remote, _) = parse_handshake_bytes(&mut peer_buf)?;
if let Some(expected) = expected {
if remote.info_hash != expected {
return Err(Error::Peer("info hash mismatch".into()));
}
}
let local = Handshake::new(remote.info_hash, local_peer_id).with_swarm_features();
if remote.peer_id == local_peer_id {
return Err(Error::Peer(
"remote peer_id matches local peer_id (self-connection)".into(),
));
}
stream.write_all(&encode_handshake_buf(&local)).await?;
let hash = remote.info_hash;
Ok((
Self {
addr,
remote_peer_id: remote.peer_id,
stream,
read_buf: Vec::with_capacity(4096),
extensions: local.extensions && remote.extensions,
fast: local.fast && remote.fast,
v2: local.v2 && remote.v2,
},
hash,
))
}
pub async fn send(&mut self, message: &PeerMessage) -> Result<()> {
let encoded = message.encode();
self.stream.write_all(&encoded).await?;
Ok(())
}
pub async fn send_extended(
&mut self,
extension_id: u8,
message: &ExtensionMessage,
) -> Result<()> {
let encoded = message.encode(extension_id);
self.stream.write_all(&encoded).await?;
Ok(())
}
pub async fn recv(&mut self) -> Result<PeerMessage> {
crate::ingress!("peer_tcp");
const IDLE_TIMEOUT: Duration = Duration::from_secs(120);
loop {
match PeerMessage::try_decode(&self.read_buf)? {
FrameDecode::Frame { message, rest } => {
self.read_buf = rest.to_vec();
return Ok(message);
}
FrameDecode::NeedMore => {}
}
if self.read_buf.len() >= MAX_PEER_READ_BUF {
return Err(Error::Peer(format!(
"peer read buffer exceeds {MAX_PEER_READ_BUF} bytes"
)));
}
let mut chunk = [0u8; 4096];
let read = tokio::time::timeout(IDLE_TIMEOUT, self.stream.read(&mut chunk))
.await
.map_err(|_| Error::Peer("peer idle/read timeout".into()))??;
if read == 0 {
return Err(Error::Peer("peer connection closed".into()));
}
self.read_buf.extend_from_slice(&chunk[..read]);
}
}
}
fn encode_handshake_buf(handshake: &Handshake) -> Vec<u8> {
let mut buf = Vec::with_capacity(68);
buf.push(19);
buf.extend(b"BitTorrent protocol");
let mut reserved = [0u8; 8];
if handshake.extensions {
crate::peer::extension::enable_extensions(&mut reserved);
}
if handshake.fast {
crate::peer::fast::enable_fast(&mut reserved);
}
if handshake.v2 {
crate::peer::hash_messages::enable_v2(&mut reserved);
}
buf.extend(reserved);
buf.extend(handshake.info_hash.as_bytes());
buf.extend(handshake.peer_id);
buf
}
fn parse_handshake_bytes(buf: &mut [u8; 68]) -> Result<(Handshake, [u8; 8])> {
if buf[0] != 19 || &buf[1..20] != b"BitTorrent protocol" {
return Err(Error::Peer("invalid handshake".into()));
}
let mut reserved = [0u8; 8];
reserved.copy_from_slice(&buf[20..28]);
let mut info_hash = [0u8; 20];
info_hash.copy_from_slice(&buf[28..48]);
let mut peer_id = [0u8; 20];
peer_id.copy_from_slice(&buf[48..68]);
Ok((
Handshake {
info_hash: InfoHash::from_bytes(info_hash),
peer_id,
extensions: crate::peer::extension::supports_extensions(&reserved),
fast: crate::peer::fast::supports_fast(&reserved),
v2: crate::peer::hash_messages::supports_v2(&reserved),
},
reserved,
))
}