use std::net::{IpAddr, SocketAddr};
use std::time::Duration;
use base64::Engine;
use futures::{SinkExt, StreamExt};
use serde_json::Value;
use tokio::net::TcpStream;
use tokio_tungstenite::tungstenite::{Message, client::IntoClientRequest};
use tracing::debug;
use crate::engine::bittorrent::tracker::communication::AnnounceEvent;
use crate::http::socks_connector::NoProxyMatcher;
use crate::http::{HttpConnectProxyTunnel, HttpProxyConfig, ProxyType};
use crate::network::OutboundNetworkPolicy;
use crate::request::request_group::DownloadOptions;
use aria2_protocol::bittorrent::tracker::public_list::TrackerFailureKind;
pub(crate) struct AnnounceRequest<'a> {
pub(crate) info_hash: &'a [u8; 20],
pub(crate) peer_id: &'a [u8; 20],
pub(crate) downloaded: u64,
pub(crate) left: u64,
pub(crate) uploaded: u64,
pub(crate) numwant: u32,
pub(crate) port: u16,
pub(crate) event: AnnounceEvent,
pub(crate) options: &'a DownloadOptions,
}
pub(crate) struct AnnounceResponse {
pub(crate) peers: Vec<SocketAddr>,
pub(crate) interval: Option<u64>,
pub(crate) min_interval: Option<u64>,
pub(crate) seeders: Option<i64>,
pub(crate) leechers: Option<i64>,
}
#[derive(Debug)]
pub(crate) struct AnnounceError {
pub(crate) kind: TrackerFailureKind,
message: String,
}
impl AnnounceError {
fn new(kind: TrackerFailureKind, message: impl Into<String>) -> Self {
Self {
kind,
message: message.into(),
}
}
}
impl std::fmt::Display for AnnounceError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str(&self.message)
}
}
pub(crate) async fn announce_with_policy(
tracker_url: &str,
announce: AnnounceRequest<'_>,
policy: &OutboundNetworkPolicy,
) -> Result<AnnounceResponse, AnnounceError> {
let url = reqwest::Url::parse(tracker_url).map_err(|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("invalid WebSocket tracker URL: {error}"),
)
})?;
let scheme = url.scheme();
if !matches!(scheme, "ws" | "wss") {
return Err(AnnounceError::new(
TrackerFailureKind::Network,
format!("unsupported WebSocket tracker scheme '{scheme}'"),
));
}
let host = url.host_str().ok_or_else(|| {
AnnounceError::new(
TrackerFailureKind::Network,
"WebSocket tracker URL has no host",
)
})?;
let port = url.port_or_known_default().ok_or_else(|| {
AnnounceError::new(
TrackerFailureKind::Network,
"WebSocket tracker URL has no port",
)
})?;
let timeout = Duration::from_secs(
announce
.options
.bt_tracker_timeout
.max(announce.options.bt_tracker_connect_timeout)
.max(1),
);
crate::http::client_pool::ensure_rustls_provider();
let stream = connect_socket(&url, host, port, announce.options, timeout, policy).await?;
let ws_request = tracker_url.into_client_request().map_err(|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("invalid WebSocket tracker request: {error}"),
)
})?;
let (mut websocket, _) = tokio::time::timeout(
timeout,
tokio_tungstenite::client_async_tls_with_config(ws_request, stream, None, None),
)
.await
.map_err(|_| {
AnnounceError::new(
TrackerFailureKind::Timeout,
"WebSocket tracker handshake timed out",
)
})?
.map_err(classify_websocket_error)?;
let mut message = serde_json::json!({
"action": "announce",
"info_hash": base64::engine::general_purpose::STANDARD.encode(announce.info_hash),
"peer_id": base64::engine::general_purpose::STANDARD.encode(announce.peer_id),
"uploaded": announce.uploaded,
"downloaded": announce.downloaded,
"left": announce.left,
"numwant": announce.numwant,
"port": announce.port,
"compact": 1,
});
if let Some(event) =
(!announce.event.as_event_string().is_empty()).then_some(announce.event.as_event_string())
{
message["event"] = Value::String(event.to_string());
}
tokio::time::timeout(timeout, websocket.send(Message::Text(message.to_string())))
.await
.map_err(|_| {
AnnounceError::new(
TrackerFailureKind::Timeout,
"WebSocket tracker announce timed out while sending",
)
})?
.map_err(|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("WebSocket tracker announce send failed: {error}"),
)
})?;
let response = tokio::time::timeout(timeout, async {
let mut response = None;
while let Some(message) = websocket.next().await {
match message {
Ok(Message::Text(text)) => {
response = Some(text.to_string());
break;
}
Ok(Message::Binary(bytes)) => {
if let Ok(text) = String::from_utf8(bytes.to_vec()) {
response = Some(text);
break;
}
}
Ok(Message::Ping(payload)) => {
websocket
.send(Message::Pong(payload))
.await
.map_err(|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("WebSocket tracker pong send failed: {error}"),
)
})?;
}
Ok(Message::Close(_)) => break,
Ok(_) => {}
Err(error) => return Err(classify_websocket_error(error)),
}
}
Ok::<_, AnnounceError>(response)
})
.await
.map_err(|_| {
AnnounceError::new(
TrackerFailureKind::Timeout,
"WebSocket tracker announce timed out while receiving",
)
})??;
let Some(response) = response else {
return Err(AnnounceError::new(
TrackerFailureKind::MalformedResponse,
"WebSocket tracker closed without an announce response",
));
};
let response: Value = serde_json::from_str(&response).map_err(|error| {
AnnounceError::new(
TrackerFailureKind::MalformedResponse,
format!("invalid WebSocket tracker response: {error}"),
)
})?;
if let Some(reason) = response.get("failure reason").and_then(Value::as_str) {
return Err(AnnounceError::new(
TrackerFailureKind::TrackerRejected,
format!("WebSocket tracker rejected announce: {reason}"),
));
}
let mut peers = response.get("peers").map(parse_peers).unwrap_or_default();
if let Some(peers6) = response.get("peers6").and_then(Value::as_str) {
peers.extend(parse_compact_peers(peers6));
}
peers.sort_unstable();
peers.dedup();
debug!(tracker = %tracker_url, peers = peers.len(), "WebSocket tracker announce completed");
Ok(AnnounceResponse {
peers,
interval: response.get("interval").and_then(Value::as_u64),
min_interval: response.get("min interval").and_then(Value::as_u64),
seeders: response.get("complete").and_then(Value::as_i64),
leechers: response.get("incomplete").and_then(Value::as_i64),
})
}
fn classify_websocket_error(error: tokio_tungstenite::tungstenite::Error) -> AnnounceError {
use tokio_tungstenite::tungstenite::Error;
let (kind, message) = match error {
Error::Http(response)
if response.status().is_server_error()
|| matches!(response.status().as_u16(), 408 | 425 | 429) =>
{
(
TrackerFailureKind::RemoteTemporary,
format!(
"WebSocket tracker rejected handshake with {}",
response.status()
),
)
}
Error::Http(response) => (
TrackerFailureKind::TrackerRejected,
format!(
"WebSocket tracker rejected handshake with {}",
response.status()
),
),
Error::Protocol(error) => (
TrackerFailureKind::MalformedResponse,
format!("invalid WebSocket tracker protocol response: {error}"),
),
error => (
TrackerFailureKind::Network,
format!("WebSocket tracker connection failed: {error}"),
),
};
AnnounceError::new(kind, message)
}
async fn connect_socket(
url: &reqwest::Url,
target_host: &str,
target_port: u16,
options: &DownloadOptions,
timeout: Duration,
policy: &OutboundNetworkPolicy,
) -> Result<TcpStream, AnnounceError> {
let no_proxy = options
.no_proxy
.as_deref()
.map(NoProxyMatcher::from_env_value)
.is_some_and(|matcher| matcher.should_bypass_hostname(target_host));
let proxy = if no_proxy {
None
} else if url.scheme() == "ws" {
options
.http_proxy
.as_deref()
.filter(|proxy| !proxy.is_empty())
.or_else(|| {
options
.all_proxy
.as_deref()
.filter(|proxy| !proxy.is_empty())
})
} else {
options
.https_proxy
.as_deref()
.filter(|proxy| !proxy.is_empty())
.or_else(|| {
options
.all_proxy
.as_deref()
.filter(|proxy| !proxy.is_empty())
})
};
let Some(proxy_url) = proxy else {
return tokio::time::timeout(timeout, policy.connect_host(target_host, target_port))
.await
.map_err(|_| {
AnnounceError::new(
TrackerFailureKind::Timeout,
"WebSocket tracker TCP connection timed out",
)
})?
.map_err(|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("WebSocket tracker TCP connection failed: {error}"),
)
});
};
let credentials_selector = if url.scheme() == "ws" {
"http"
} else {
"https"
};
let credentials = if (url.scheme() == "ws" && options.http_proxy.as_deref() == Some(proxy_url))
|| (url.scheme() == "wss" && options.https_proxy.as_deref() == Some(proxy_url))
{
options.proxy_credentials_for_scheme(credentials_selector)
} else {
options.proxy_credentials_for_scheme("all")
};
let mut config =
HttpProxyConfig::from_proxy_url(proxy_url, target_host.to_string(), target_port).map_err(
|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("invalid WebSocket proxy configuration: {error}"),
)
},
)?;
if config.proxy_type != ProxyType::Http {
return Err(AnnounceError::new(
TrackerFailureKind::Network,
format!(
"WebSocket tracker proxy must use an HTTP CONNECT proxy; '{}' is {}",
proxy_url, config.proxy_type
),
));
}
if let Some(username) = credentials.0 {
config = config.with_credentials(username, credentials.1.unwrap_or_default());
}
config.connect_timeout = timeout;
config.read_timeout = timeout;
config.write_timeout = timeout;
tokio::time::timeout(
timeout,
HttpConnectProxyTunnel::new(config).connect_with_policy(policy),
)
.await
.map_err(|_| {
AnnounceError::new(
TrackerFailureKind::Timeout,
"WebSocket tracker proxy connection timed out",
)
})?
.map_err(|error| {
AnnounceError::new(
TrackerFailureKind::Network,
format!("WebSocket tracker proxy connection failed: {error}"),
)
})
}
fn parse_peers(value: &Value) -> Vec<SocketAddr> {
match value {
Value::Array(peers) => peers.iter().flat_map(parse_peer).collect(),
Value::String(peers) => parse_peer_string(peers),
_ => Vec::new(),
}
}
fn parse_peer(value: &Value) -> Vec<SocketAddr> {
match value {
Value::Object(peer) => {
let Some(ip) = peer.get("ip").and_then(Value::as_str) else {
return Vec::new();
};
let Some(port) = peer
.get("port")
.and_then(Value::as_u64)
.and_then(|port| u16::try_from(port).ok())
else {
return Vec::new();
};
tracker_peer_socket_addr(ip, port).into_iter().collect()
}
Value::String(peer) => parse_peer_string(peer),
_ => Vec::new(),
}
}
fn parse_peer_string(peer: &str) -> Vec<SocketAddr> {
if let Ok(address) = peer.parse::<SocketAddr>() {
return vec![address];
}
parse_compact_peers(peer)
}
fn parse_compact_peers(encoded: &str) -> Vec<SocketAddr> {
let Ok(bytes) = base64::engine::general_purpose::STANDARD.decode(encoded) else {
return Vec::new();
};
let mut peers = Vec::new();
if bytes.len() % 6 == 0 {
for chunk in bytes.as_chunks::<6>().0 {
let ip = IpAddr::from([chunk[0], chunk[1], chunk[2], chunk[3]]);
let port = u16::from_be_bytes([chunk[4], chunk[5]]);
peers.push(SocketAddr::new(ip, port));
}
} else if bytes.len() % 18 == 0 {
for chunk in bytes.as_chunks::<18>().0 {
let mut octets = [0u8; 16];
octets.copy_from_slice(&chunk[..16]);
let ip = IpAddr::from(octets);
let port = u16::from_be_bytes([chunk[16], chunk[17]]);
peers.push(SocketAddr::new(ip, port));
}
}
peers
}
fn tracker_peer_socket_addr(ip: &str, port: u16) -> Option<SocketAddr> {
ip.parse::<IpAddr>()
.ok()
.map(|ip| SocketAddr::new(ip, port))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_json_and_compact_peers() {
let compact = base64::engine::general_purpose::STANDARD.encode([192, 0, 2, 1, 0x1a, 0xe1]);
let value = serde_json::json!({
"peers": [
{"ip": "192.0.2.2", "port": 6882},
compact,
]
});
let mut peers = parse_peers(value.get("peers").unwrap());
peers.sort_unstable();
assert_eq!(
peers,
vec![
"192.0.2.1:6881".parse().unwrap(),
"192.0.2.2:6882".parse().unwrap(),
]
);
}
#[tokio::test]
async fn announces_to_a_websocket_tracker() {
use tokio::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
let mut websocket = tokio_tungstenite::accept_async(stream).await.unwrap();
let Some(Ok(Message::Text(request))) = websocket.next().await else {
panic!("tracker did not receive an announce")
};
let request: Value = serde_json::from_str(&request).unwrap();
assert_eq!(request["action"], "announce");
websocket
.send(Message::Text(
serde_json::json!({
"peers": [{"ip": "192.0.2.10", "port": 6881}]
})
.to_string(),
))
.await
.unwrap();
});
let peers = announce_with_policy(
&format!("ws://{address}/announce"),
AnnounceRequest {
info_hash: &[1u8; 20],
peer_id: &[2u8; 20],
downloaded: 0,
left: 1,
uploaded: 0,
numwant: 50,
port: 0,
event: AnnounceEvent::Started,
options: &DownloadOptions::default(),
},
&OutboundNetworkPolicy::direct(),
)
.await
.unwrap();
server.await.unwrap();
assert_eq!(peers.peers, vec!["192.0.2.10:6881".parse().unwrap()]);
}
}