Compile times are even worse now

crates/tracker_comms/src/lib.rs

@@ -0,0 +1,5 @@
+mod tracker_comms;
+mod tracker_comms_http;
+mod tracker_comms_udp;
+
+pub use tracker_comms::*;

crates/tracker_comms/src/tracker_comms.rs

@@ -0,0 +1,281 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::bail;
+use anyhow::Context;
+use futures::future::Either;
+use futures::stream::FuturesUnordered;
+use futures::FutureExt;
+use futures::Stream;
+use futures::StreamExt;
+use tracing::debug;
+use tracing::error_span;
+use tracing::trace;
+use tracing::Instrument;
+use url::Url;
+
+use crate::tracker_comms_http;
+use crate::tracker_comms_udp;
+use librqbit_core::hash_id::Id20;
+
+pub struct TrackerComms {
+    info_hash: Id20,
+    peer_id: Id20,
+    stats: Box<dyn TorrentStatsProvider>,
+    force_tracker_interval: Option<Duration>,
+    tx: Sender,
+    tcp_listen_port: Option<u16>,
+}
+
+#[derive(Default)]
+pub struct TrackerCommsStats {
+    pub uploaded_bytes: u64,
+    pub downloaded_bytes: u64,
+    pub total_bytes: u64,
+}
+
+impl TrackerCommsStats {
+    pub fn get_left_to_download_bytes(&self) -> u64 {
+        let total = self.total_bytes;
+        let down = self.downloaded_bytes;
+        if total >= down {
+            return total - down;
+        }
+        0
+    }
+}
+
+pub trait TorrentStatsProvider: Send + Sync {
+    fn get(&self) -> TrackerCommsStats;
+}
+
+impl TorrentStatsProvider for () {
+    fn get(&self) -> TrackerCommsStats {
+        Default::default()
+    }
+}
+
+type Sender = tokio::sync::mpsc::Sender<SocketAddr>;
+
+impl TrackerComms {
+    pub fn start(
+        info_hash: Id20,
+        peer_id: Id20,
+        trackers: Vec<String>,
+        stats: Box<dyn TorrentStatsProvider>,
+        force_interval: Option<Duration>,
+        tcp_listen_port: Option<u16>,
+    ) -> Option<impl Stream<Item = SocketAddr> + Unpin + Send + 'static> {
+        let trackers = trackers
+            .into_iter()
+            .filter_map(|t| match Url::parse(&t) {
+                Ok(parsed) => Some(parsed),
+                Err(e) => {
+                    debug!("error parsing tracker URL: {}", e);
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        if trackers.is_empty() {
+            return None;
+        }
+
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<SocketAddr>(16);
+
+        let s = async_stream::stream! {
+            use futures::StreamExt;
+            let mut rx_done = false;
+            let comms = Arc::new(Self {
+                info_hash,
+                peer_id,
+                stats,
+                force_tracker_interval: force_interval,
+                tx,
+                tcp_listen_port,
+            });
+            let mut futures = FuturesUnordered::new();
+            for tracker in trackers {
+                if let Ok(fut) = comms.add_tracker(tracker) {
+                    futures.push(fut);
+                }
+            }
+            if futures.is_empty() {
+                return;
+            }
+            while !(futures.is_empty() && rx_done) {
+                tokio::select! {
+                    addr = rx.recv(), if !rx_done => {
+                        match addr {
+                            Some(addr) => yield addr,
+                            None => rx_done = true
+                        }
+                    }
+                    e = futures.next(), if !futures.is_empty() => {
+                        if let Some(Err(e)) = e {
+                            debug!("error: {e}");
+                        }
+                    }
+                }
+            }
+        };
+
+        Some(s.boxed())
+    }
+
+    fn add_tracker(
+        &self,
+        url: Url,
+    ) -> anyhow::Result<
+        Either<
+            impl std::future::Future<Output = anyhow::Result<()>> + '_ + Send,
+            impl std::future::Future<Output = anyhow::Result<()>> + '_ + Send,
+        >,
+    > {
+        let info_hash = self.info_hash;
+        if url.scheme() == "http" || url.scheme() == "https" {
+            let span = error_span!(
+                parent: None,
+                "http_tracker",
+                tracker = %url,
+                info_hash = ?info_hash
+            );
+            Ok(self
+                .task_single_tracker_monitor_http(url)
+                .instrument(span)
+                .left_future())
+        } else if url.scheme() == "udp" {
+            let span =
+                error_span!(parent: None, "udp_tracker", tracker = %url, info_hash = ?info_hash);
+            Ok(self
+                .task_single_tracker_monitor_udp(url)
+                .instrument(span)
+                .right_future())
+        } else {
+            bail!("unsupported tracker url {}", url)
+        }
+    }
+
+    async fn task_single_tracker_monitor_http(&self, mut tracker_url: Url) -> anyhow::Result<()> {
+        let mut event = Some(tracker_comms_http::TrackerRequestEvent::Started);
+        loop {
+            let stats = self.stats.get();
+            let request = tracker_comms_http::TrackerRequest {
+                info_hash: self.info_hash,
+                peer_id: self.peer_id,
+                port: 6778,
+                uploaded: stats.uploaded_bytes,
+                downloaded: stats.downloaded_bytes,
+                left: stats.get_left_to_download_bytes(),
+                compact: true,
+                no_peer_id: false,
+                event,
+                ip: None,
+                numwant: None,
+                key: None,
+                trackerid: None,
+            };
+
+            let request_query = request.as_querystring();
+            tracker_url.set_query(Some(&request_query));
+
+            match self.tracker_one_request_http(tracker_url.clone()).await {
+                Ok(interval) => {
+                    event = None;
+                    let interval = self
+                        .force_tracker_interval
+                        .unwrap_or_else(|| Duration::from_secs(interval));
+                    debug!(
+                        "sleeping for {:?} after calling tracker {}",
+                        interval,
+                        tracker_url.host().unwrap()
+                    );
+                    tokio::time::sleep(interval).await;
+                }
+                Err(e) => {
+                    debug!("error calling the tracker {}: {:#}", tracker_url, e);
+                    tokio::time::sleep(Duration::from_secs(60)).await;
+                }
+            };
+        }
+    }
+
+    async fn tracker_one_request_http(&self, tracker_url: Url) -> anyhow::Result<u64> {
+        let response: reqwest::Response = reqwest::get(tracker_url).await?;
+        if !response.status().is_success() {
+            anyhow::bail!("tracker responded with {:?}", response.status());
+        }
+        let bytes = response.bytes().await?;
+        if let Ok(error) = bencode::from_bytes::<tracker_comms_http::TrackerError>(&bytes) {
+            anyhow::bail!(
+                "tracker returned failure. Failure reason: {}",
+                error.failure_reason
+            )
+        };
+        let response = bencode::from_bytes::<tracker_comms_http::TrackerResponse>(&bytes)?;
+
+        for peer in response.peers.iter_sockaddrs() {
+            self.tx.send(peer).await?;
+        }
+        Ok(response.interval)
+    }
+
+    async fn task_single_tracker_monitor_udp(&self, url: Url) -> anyhow::Result<()> {
+        use tracker_comms_udp::*;
+
+        if url.scheme() != "udp" {
+            bail!("expected UDP scheme in {}", url);
+        }
+        let hp: (&str, u16) = (
+            url.host_str().context("missing host")?,
+            url.port().context("missing port")?,
+        );
+        let mut requester = UdpTrackerRequester::new(hp)
+            .await
+            .context("error creating UDP tracker requester")?;
+
+        let mut sleep_interval: Option<Duration> = None;
+        loop {
+            if let Some(i) = sleep_interval {
+                trace!(interval=?sleep_interval, "sleeping");
+                tokio::time::sleep(i).await;
+            }
+
+            let stats = self.stats.get();
+            let request = AnnounceFields {
+                info_hash: self.info_hash,
+                peer_id: self.peer_id,
+                downloaded: stats.downloaded_bytes,
+                left: stats.get_left_to_download_bytes(),
+                uploaded: stats.uploaded_bytes,
+                event: EVENT_NONE,
+                key: 0, // whatever that is?
+                port: self.tcp_listen_port.unwrap_or(0),
+            };
+
+            match requester.announce(request).await {
+                Ok(response) => {
+                    trace!(len = response.addrs.len(), "received announce response");
+                    for addr in response.addrs {
+                        self.tx
+                            .send(SocketAddr::V4(addr))
+                            .await
+                            .context("rx closed")?;
+                    }
+                    let new_interval = response.interval.max(5);
+                    let new_interval = Duration::from_secs(new_interval as u64);
+                    sleep_interval = Some(self.force_tracker_interval.unwrap_or(new_interval));
+                }
+                Err(e) => {
+                    debug!(url = ?url, "error reading announce response: {e:#}");
+                    if sleep_interval.is_none() {
+                        sleep_interval = Some(
+                            self.force_tracker_interval
+                                .unwrap_or(Duration::from_secs(60)),
+                        );
+                    }
+                }
+            }
+        }
+    }
+}

crates/tracker_comms/src/tracker_comms_http.rs

@@ -0,0 +1,233 @@
+use buffers::ByteBuf;
+use byteorder::ByteOrder;
+use serde::{Deserialize, Deserializer};
+use std::{
+    fmt::Write,
+    marker::PhantomData,
+    net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4},
+    str::FromStr,
+};
+
+use librqbit_core::hash_id::Id20;
+
+#[derive(Clone, Copy)]
+pub enum TrackerRequestEvent {
+    Started,
+    #[allow(dead_code)]
+    Stopped,
+    #[allow(dead_code)]
+    Completed,
+}
+
+pub struct TrackerRequest {
+    pub info_hash: Id20,
+    pub peer_id: Id20,
+    pub event: Option<TrackerRequestEvent>,
+    pub port: u16,
+    pub uploaded: u64,
+    pub downloaded: u64,
+    pub left: u64,
+    pub compact: bool,
+    pub no_peer_id: bool,
+
+    pub ip: Option<std::net::IpAddr>,
+    pub numwant: Option<usize>,
+    pub key: Option<String>,
+    pub trackerid: Option<String>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct TrackerError<'a> {
+    #[serde(rename = "failure reason", borrow)]
+    pub failure_reason: ByteBuf<'a>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct DictPeer<'a> {
+    #[serde(deserialize_with = "deserialize_ip_string")]
+    ip: IpAddr,
+    #[serde(borrow)]
+    #[allow(dead_code)]
+    peer_id: Option<ByteBuf<'a>>,
+    port: u16,
+}
+
+impl<'a> DictPeer<'a> {
+    fn as_sockaddr(&self) -> SocketAddr {
+        SocketAddr::new(self.ip, self.port)
+    }
+}
+
+#[derive(Debug)]
+pub struct Peers {
+    addrs: Vec<SocketAddr>,
+}
+
+impl Peers {
+    pub fn iter_sockaddrs(&self) -> impl Iterator<Item = std::net::SocketAddr> + '_ {
+        self.addrs.iter().copied()
+    }
+}
+
+impl<'de> serde::de::Deserialize<'de> for Peers {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor<'de> {
+            phantom: std::marker::PhantomData<&'de ()>,
+        }
+        impl<'de> serde::de::Visitor<'de> for Visitor<'de> {
+            type Value = Peers;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a list of peers in dict or binary format")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let mut peers = Vec::new();
+                while let Some(peer) = seq.next_element::<DictPeer>()? {
+                    peers.push(peer.as_sockaddr())
+                }
+                Ok(Peers { addrs: peers })
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Peers {
+                    addrs: parse_compact_peers(v)
+                        .into_iter()
+                        .map(|v| v.into())
+                        .collect(),
+                })
+            }
+        }
+        deserializer.deserialize_any(Visitor {
+            phantom: PhantomData,
+        })
+    }
+}
+
+fn deserialize_ip_string<'de, D>(de: D) -> Result<IpAddr, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct Visitor;
+    impl<'de> serde::de::Visitor<'de> for Visitor {
+        type Value = IpAddr;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("expecting an IPv4 address")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            IpAddr::from_str(v).map_err(|e| E::custom(format!("cannot parse ip: {e}")))
+        }
+    }
+    de.deserialize_str(Visitor {})
+}
+
+fn parse_compact_peers(b: &[u8]) -> Vec<SocketAddrV4> {
+    let mut ips = Vec::new();
+    for chunk in b.chunks_exact(6) {
+        let ip_chunk = &chunk[..4];
+        let port_chunk = &chunk[4..6];
+        let ipaddr = Ipv4Addr::new(ip_chunk[0], ip_chunk[1], ip_chunk[2], ip_chunk[3]);
+        let port = byteorder::BigEndian::read_u16(port_chunk);
+        ips.push(SocketAddrV4::new(ipaddr, port));
+    }
+    ips
+}
+
+#[derive(Deserialize, Debug)]
+pub struct TrackerResponse<'a> {
+    #[serde(rename = "warning message", borrow)]
+    pub warning_message: Option<ByteBuf<'a>>,
+    pub complete: u64,
+    pub interval: u64,
+    #[serde(rename = "min interval")]
+    pub min_interval: Option<u64>,
+    pub tracker_id: Option<ByteBuf<'a>>,
+    pub incomplete: u64,
+    pub peers: Peers,
+}
+
+impl TrackerRequest {
+    pub fn as_querystring(&self) -> String {
+        use urlencoding as u;
+        let mut s = String::new();
+        s.push_str("info_hash=");
+        s.push_str(u::encode_binary(&self.info_hash.0).as_ref());
+        s.push_str("&peer_id=");
+        s.push_str(u::encode_binary(&self.peer_id.0).as_ref());
+        if let Some(event) = self.event {
+            write!(
+                s,
+                "&event={}",
+                match event {
+                    TrackerRequestEvent::Started => "started",
+                    TrackerRequestEvent::Stopped => "stopped",
+                    TrackerRequestEvent::Completed => "completed",
+                }
+            )
+            .unwrap();
+        }
+        write!(s, "&port={}", self.port).unwrap();
+        write!(s, "&uploaded={}", self.uploaded).unwrap();
+        write!(s, "&downloaded={}", self.downloaded).unwrap();
+        write!(s, "&left={}", self.left).unwrap();
+        write!(s, "&compact={}", if self.compact { 1 } else { 0 }).unwrap();
+        write!(s, "&no_peer_id={}", if self.no_peer_id { 1 } else { 0 }).unwrap();
+        if let Some(ip) = &self.ip {
+            write!(s, "&ip={ip}").unwrap();
+        }
+        if let Some(numwant) = &self.numwant {
+            write!(s, "&numwant={numwant}").unwrap();
+        }
+        if let Some(key) = &self.key {
+            write!(s, "&key={key}").unwrap();
+        }
+        if let Some(trackerid) = &self.trackerid {
+            write!(s, "&trackerid={trackerid}").unwrap();
+        }
+        s
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_serialize() {
+        let info_hash = Id20::new([
+            1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+        ]);
+        let peer_id = Id20::new([
+            1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+        ]);
+        let request = TrackerRequest {
+            info_hash,
+            peer_id,
+            port: 6881,
+            uploaded: 0,
+            downloaded: 0,
+            left: 1024 * 1024,
+            compact: true,
+            no_peer_id: false,
+            event: Some(TrackerRequestEvent::Started),
+            ip: Some("127.0.0.1".parse().unwrap()),
+            numwant: None,
+            key: None,
+            trackerid: None,
+        };
+        dbg!(request.as_querystring());
+    }
+}

crates/tracker_comms/src/tracker_comms_udp.rs

@@ -0,0 +1,341 @@
+use std::net::{Ipv4Addr, SocketAddrV4};
+
+use anyhow::{bail, Context};
+use librqbit_core::hash_id::Id20;
+use rand::Rng;
+use tokio::net::ToSocketAddrs;
+use tracing::trace;
+
+const ACTION_CONNECT: u32 = 0;
+const ACTION_ANNOUNCE: u32 = 1;
+// const ACTION_SCRAPE: u32 = 2;
+// const ACTION_ERROR: u32 = 3;
+
+pub const EVENT_NONE: u32 = 0;
+// pub const EVENT_COMPLETED: u32 = 1;
+// pub const EVENT_STARTED: u32 = 2;
+// pub const EVENT_STOPPED: u32 = 3;
+
+pub type ConnectionId = u64;
+const CONNECTION_ID_MAGIC: ConnectionId = 0x41727101980;
+
+pub type TransactionId = u32;
+
+pub fn new_transaction_id() -> TransactionId {
+    rand::thread_rng().gen()
+}
+
+#[derive(Debug)]
+pub struct AnnounceFields {
+    pub info_hash: Id20,
+    pub peer_id: Id20,
+    pub downloaded: u64,
+    pub left: u64,
+    pub uploaded: u64,
+    pub event: u32,
+    pub key: u32,
+    pub port: u16,
+}
+
+#[derive(Debug)]
+pub enum Request {
+    Connect,
+    Announce(ConnectionId, AnnounceFields),
+}
+
+impl Request {
+    pub fn serialize(&self, transaction_id: TransactionId, buf: &mut Vec<u8>) -> usize {
+        let cur_len = buf.len();
+        match self {
+            Request::Connect => {
+                buf.extend_from_slice(&CONNECTION_ID_MAGIC.to_be_bytes());
+                buf.extend_from_slice(&ACTION_CONNECT.to_be_bytes());
+                buf.extend_from_slice(&transaction_id.to_be_bytes());
+            }
+            Request::Announce(connection_id, fields) => {
+                buf.extend_from_slice(&connection_id.to_be_bytes());
+                buf.extend_from_slice(&ACTION_ANNOUNCE.to_be_bytes());
+                buf.extend_from_slice(&transaction_id.to_be_bytes());
+                buf.extend_from_slice(&fields.info_hash.0);
+                buf.extend_from_slice(&fields.peer_id.0);
+                buf.extend_from_slice(&fields.downloaded.to_be_bytes());
+                buf.extend_from_slice(&fields.left.to_be_bytes());
+                buf.extend_from_slice(&fields.uploaded.to_be_bytes());
+                buf.extend_from_slice(&fields.event.to_be_bytes());
+                buf.extend_from_slice(&0u32.to_be_bytes()); // ip address 0
+                buf.extend_from_slice(&fields.key.to_be_bytes());
+                buf.extend_from_slice(&(-1i32).to_be_bytes()); // num want -1
+                buf.extend_from_slice(&fields.port.to_be_bytes());
+            }
+        }
+        buf.len() - cur_len
+    }
+}
+
+#[derive(Debug)]
+pub struct AnnounceResponse {
+    pub interval: u32,
+    pub leechers: u32,
+    pub seeders: u32,
+    pub addrs: Vec<SocketAddrV4>,
+}
+
+#[derive(Debug)]
+pub enum Response {
+    Connect(ConnectionId),
+    Announce(AnnounceResponse),
+}
+
+fn split_slice(s: &[u8], first_len: usize) -> Option<(&[u8], &[u8])> {
+    if s.len() < first_len {
+        return None;
+    }
+    Some(s.split_at(first_len))
+}
+
+fn s_to_arr<const T: usize>(buf: &[u8]) -> [u8; T] {
+    let mut arr = [0u8; T];
+    arr.copy_from_slice(buf);
+    arr
+}
+
+trait ParseNum: Sized {
+    fn parse_num(buf: &[u8]) -> anyhow::Result<(Self, &[u8])>;
+}
+
+macro_rules! parse_impl {
+    ($ty:tt, $size:expr) => {
+        impl ParseNum for $ty {
+            fn parse_num(buf: &[u8]) -> anyhow::Result<($ty, &[u8])> {
+                let (bytes, rest) =
+                    split_slice(buf, $size).with_context(|| format!("expected {} bytes", $size))?;
+                let num = $ty::from_be_bytes(s_to_arr(bytes));
+                Ok((num, rest))
+            }
+        }
+    };
+}
+
+parse_impl!(u32, 4);
+parse_impl!(u64, 8);
+parse_impl!(u16, 2);
+parse_impl!(i32, 4);
+parse_impl!(i64, 8);
+parse_impl!(i16, 2);
+
+impl Response {
+    pub fn parse(buf: &[u8]) -> anyhow::Result<(TransactionId, Self)> {
+        let (action, buf) = u32::parse_num(buf).context("can't parse action")?;
+        let (tid, mut buf) = u32::parse_num(buf).context("can't parse transaction id")?;
+        let response = match action {
+            ACTION_CONNECT => {
+                let (connection_id, b) =
+                    u64::parse_num(buf).context("can't parse connection id")?;
+                buf = b;
+                Response::Connect(connection_id)
+            }
+            ACTION_ANNOUNCE => {
+                let (interval, b) = u32::parse_num(buf).context("can't parse interval")?;
+                let (leechers, b) = u32::parse_num(b).context("can't parse leechers")?;
+                let (seeders, mut b) = u32::parse_num(b).context("can't parse seeders")?;
+                let mut addrs = Vec::new();
+                while !b.is_empty() {
+                    let (ip, b2) = u32::parse_num(b)?;
+                    let ip = Ipv4Addr::from(ip);
+                    b = b2;
+
+                    let (port, b2) = u16::parse_num(b)?;
+                    b = b2;
+                    addrs.push(SocketAddrV4::new(ip, port));
+                }
+                buf = b;
+                Response::Announce(AnnounceResponse {
+                    interval,
+                    leechers,
+                    seeders,
+                    addrs,
+                })
+            }
+            _ => bail!("unsupported action {action}"),
+        };
+
+        if !buf.is_empty() {
+            bail!(
+                "parsed {response:?} so far, but got {} remaining bytes",
+                buf.len()
+            );
+        }
+
+        Ok((tid, response))
+    }
+}
+
+pub struct UdpTrackerRequester {
+    sock: tokio::net::UdpSocket,
+    connection_id: ConnectionId,
+    read_buf: Vec<u8>,
+    write_buf: Vec<u8>,
+}
+
+impl UdpTrackerRequester {
+    // Addr is "host:port"
+    pub async fn new(addr: impl ToSocketAddrs) -> anyhow::Result<Self> {
+        let sock = tokio::net::UdpSocket::bind("0.0.0.0:0")
+            .await
+            .context("error binding UDP socket")?;
+        sock.connect(addr)
+            .await
+            .context("error connecting UDP socket")?;
+
+        let tid = new_transaction_id();
+        let mut write_buf = Vec::new();
+        let mut read_buf = vec![0u8; 4096];
+
+        trace!("sending connect request");
+        Request::Connect.serialize(tid, &mut write_buf);
+
+        sock.send(&write_buf)
+            .await
+            .context("error sending to socket")?;
+
+        let size = sock
+            .recv(&mut read_buf)
+            .await
+            .context("error receiving from socket")?;
+
+        let (rtid, response) =
+            Response::parse(&read_buf[..size]).context("error parsing response")?;
+        if tid != rtid {
+            bail!("expected transaction id {} == {}", tid, rtid);
+        }
+        trace!(response=?response, "received");
+
+        let connection_id = match response {
+            Response::Connect(connection_id) => connection_id,
+            other => bail!("unexpected response {other:?}"),
+        };
+
+        trace!(connection_id);
+
+        Ok(Self {
+            sock,
+            connection_id,
+            read_buf,
+            write_buf,
+        })
+    }
+
+    pub async fn announce(&mut self, fields: AnnounceFields) -> anyhow::Result<AnnounceResponse> {
+        let request = Request::Announce(self.connection_id, fields);
+        let response = self.request(request).await?;
+        match response {
+            Response::Announce(r) => Ok(r),
+            other => bail!("unexpected response {other:?}, expected announce"),
+        }
+    }
+
+    pub async fn request(&mut self, request: Request) -> anyhow::Result<Response> {
+        let tid = new_transaction_id();
+        self.write_buf.clear();
+        let size = request.serialize(tid, &mut self.write_buf);
+        trace!(request=?request, tid, "sending");
+        self.sock
+            .send(&self.write_buf[..size])
+            .await
+            .context("error sending")?;
+        let size = self.sock.recv(&mut self.read_buf).await.unwrap();
+
+        let (rtid, response) = Response::parse(&self.read_buf[..size]).unwrap();
+        trace!("received response");
+        if tid != rtid {
+            bail!("unexpected transaction id");
+        }
+        Ok(response)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{io::Write, str::FromStr};
+
+    use librqbit_core::{hash_id::Id20, peer_id::generate_peer_id};
+
+    use crate::tracker_comms_udp::{
+        new_transaction_id, AnnounceFields, Request, Response, EVENT_NONE,
+    };
+
+    #[test]
+    fn test_parse_announce() {
+        let b = include_bytes!("../resources/test/udp-tracker-announce-response.bin");
+        let (tid, response) = Response::parse(b).unwrap();
+        dbg!(tid, response);
+    }
+
+    #[ignore]
+    #[tokio::test]
+    async fn test_announce() {
+        let sock = tokio::net::UdpSocket::bind("0.0.0.0:0").await.unwrap();
+        sock.connect("opentor.net:6969").await.unwrap();
+
+        let tid = new_transaction_id();
+        let mut write_buf = Vec::new();
+        let mut read_buf = vec![0u8; 4096];
+
+        Request::Connect.serialize(tid, &mut write_buf);
+
+        sock.send(&write_buf).await.unwrap();
+
+        let size = sock.recv(&mut read_buf).await.unwrap();
+
+        let (rtid, response) = Response::parse(&read_buf[..size]).unwrap();
+        assert_eq!(tid, rtid);
+        let connection_id = match response {
+            Response::Connect(connection_id) => {
+                dbg!(connection_id)
+            }
+            other => panic!("unexpected response {:?}", other),
+        };
+
+        let hash = Id20::from_str("775459190aa65566591634203f8d9f17d341f969").unwrap();
+
+        let tid = new_transaction_id();
+        let request = Request::Announce(
+            connection_id,
+            AnnounceFields {
+                info_hash: hash,
+                peer_id: generate_peer_id(),
+                downloaded: 0,
+                left: 0,
+                uploaded: 0,
+                event: EVENT_NONE,
+                key: 0, // whatever that is?
+                port: 24563,
+            },
+        );
+        write_buf.clear();
+        let size = request.serialize(tid, &mut write_buf);
+
+        sock.send(&write_buf[..size]).await.unwrap();
+        let size = sock.recv(&mut read_buf).await.unwrap();
+
+        {
+            let mut f = std::fs::OpenOptions::new()
+                .create(true)
+                .truncate(true)
+                .write(true)
+                .open("/tmp/proto.bin")
+                .unwrap();
+            f.write_all(&read_buf[..size]).unwrap();
+        }
+
+        dbg!(&read_buf[..size]);
+        let (rtid, response) = Response::parse(&read_buf[..size]).unwrap();
+        assert_eq!(tid, rtid);
+        match response {
+            Response::Announce(r) => {
+                dbg!(r);
+            }
+            other => panic!("unexpected response {:?}", other),
+        }
+    }
+}