use std::net::SocketAddr;
use std::time::Duration;
use tokio::net::UdpSocket;
use tokio::time::timeout;
use crate::error::{Error, Result};
use crate::tracker::AnnounceEvent;
use crate::wire::decode_peers_auto;
const PROTOCOL_ID: u64 = 0x4172_7109_1980;
const ACTION_CONNECT: u32 = 0;
const ACTION_ANNOUNCE: u32 = 1;
const ACTION_CONNECT_RESPONSE: u32 = 0;
const ACTION_ANNOUNCE_RESPONSE: u32 = 1;
#[allow(clippy::too_many_arguments)]
pub async fn announce_udp(
tracker: SocketAddr,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
port: u16,
uploaded: u64,
downloaded: u64,
left: u64,
event: AnnounceEvent,
) -> Result<crate::tracker::AnnounceResponse> {
let socket = UdpSocket::bind("0.0.0.0:0").await?;
socket.connect(tracker).await?;
let connection_id = connect(&socket, tracker).await?;
announce_with_connection(
&socket,
tracker,
connection_id,
info_hash,
peer_id,
port,
uploaded,
downloaded,
left,
event,
)
.await
}
async fn connect(socket: &UdpSocket, tracker: SocketAddr) -> Result<u64> {
let tx = udp_tx()?;
let packet = build_connect(tx);
socket.send(&packet).await?;
let mut buf = [0u8; 16];
let len = timeout(Duration::from_secs(5), socket.recv(&mut buf))
.await
.map_err(|_| Error::Tracker(format!("udp connect timed out for {tracker}")))?
.map_err(Error::from)?;
if len < 16 {
return Err(Error::Tracker("udp connect response too short".into()));
}
let action = u32::from_be_bytes(buf[0..4].try_into().expect("action"));
if action != ACTION_CONNECT_RESPONSE {
return Err(Error::Tracker(format!("unexpected udp connect action {action}")));
}
if buf[4..8] != tx {
return Err(Error::Tracker("udp connect transaction mismatch".into()));
}
Ok(u64::from_be_bytes(buf[8..16].try_into().expect("connection id")))
}
#[allow(clippy::too_many_arguments)]
async fn announce_with_connection(
socket: &UdpSocket,
tracker: SocketAddr,
connection_id: u64,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
port: u16,
uploaded: u64,
downloaded: u64,
left: u64,
event: AnnounceEvent,
) -> Result<crate::tracker::AnnounceResponse> {
let tx = udp_tx()?;
let key = u32::from_be_bytes(crate::net::random_bytes::<4>()?);
let packet = build_announce(
connection_id,
tx,
info_hash,
peer_id,
port,
uploaded,
downloaded,
left,
event,
key,
);
socket.send(&packet).await?;
let mut buf = vec![0u8; 8192];
let len = timeout(Duration::from_secs(5), socket.recv(&mut buf))
.await
.map_err(|_| Error::Tracker(format!("udp announce timed out for {tracker}")))?
.map_err(Error::from)?;
parse_announce_response(&buf[..len], &tx)
}
fn build_connect(transaction_id: [u8; 4]) -> [u8; 16] {
let mut out = [0u8; 16];
out[0..8].copy_from_slice(&PROTOCOL_ID.to_be_bytes());
out[8..12].copy_from_slice(&ACTION_CONNECT.to_be_bytes());
out[12..16].copy_from_slice(&transaction_id);
out
}
#[allow(clippy::too_many_arguments)]
fn build_announce(
connection_id: u64,
transaction_id: [u8; 4],
info_hash: &[u8; 20],
peer_id: &[u8; 20],
port: u16,
uploaded: u64,
downloaded: u64,
left: u64,
event: AnnounceEvent,
key: u32,
) -> Vec<u8> {
let mut out = Vec::with_capacity(98);
out.extend(connection_id.to_be_bytes());
out.extend(ACTION_ANNOUNCE.to_be_bytes());
out.extend(transaction_id);
out.extend(info_hash);
out.extend(peer_id);
out.extend(downloaded.to_be_bytes());
out.extend(left.to_be_bytes());
out.extend(uploaded.to_be_bytes());
out.extend(event_code(event).to_be_bytes());
out.extend(0u32.to_be_bytes()); out.extend(key.to_be_bytes());
out.extend((-1i32).to_be_bytes()); out.extend(port.to_be_bytes());
out
}
fn parse_announce_response(
buf: &[u8],
expected_tx: &[u8; 4],
) -> Result<crate::tracker::AnnounceResponse> {
if buf.len() < 20 {
return Err(Error::Tracker("udp announce response too short".into()));
}
let action = u32::from_be_bytes(buf[0..4].try_into().expect("action"));
if action != ACTION_ANNOUNCE_RESPONSE {
return Err(Error::Tracker(format!("unexpected udp announce action {action}")));
}
if &buf[4..8] != expected_tx {
return Err(Error::Tracker("udp announce transaction mismatch".into()));
}
let interval_secs = u32::from_be_bytes(buf[8..12].try_into().expect("interval"));
Ok(crate::tracker::AnnounceResponse {
peers: decode_peers_auto(&buf[20..]),
interval_secs: Some(interval_secs).filter(|&v| v > 0),
min_interval_secs: None,
})
}
fn event_code(event: AnnounceEvent) -> u32 {
match event {
AnnounceEvent::None => 0,
AnnounceEvent::Completed => 1,
AnnounceEvent::Started => 2,
AnnounceEvent::Stopped => 3,
}
}
fn udp_tx() -> Result<[u8; 4]> {
crate::net::random_bytes::<4>()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn connect_packet_size() {
let packet = build_connect([1, 2, 3, 4]);
assert_eq!(packet.len(), 16);
assert_eq!(&packet[0..8], &PROTOCOL_ID.to_be_bytes());
}
#[test]
fn announce_packet_layout() {
let packet = build_announce(
0x1234,
[9, 9, 9, 9],
&[1; 20],
&[2; 20],
6881,
0,
0,
1000,
AnnounceEvent::Started,
0xAABB_CCDD,
);
assert_eq!(packet.len(), 98);
}
}