udp: split AnnounceResponse into V4 and V6 versions

aquatic_udp/src/lib/common/mod.rs

@@ -18,35 +18,6 @@ pub mod network;
 
 pub const MAX_PACKET_SIZE: usize = 8192;
 
-#[derive(Debug)]
-pub enum ConnectedRequest {
-    Announce(AnnounceRequest),
-    Scrape {
-        request: ScrapeRequest,
-        /// Currently only used by glommio implementation
-        original_indices: Vec<usize>,
-    },
-}
-
-#[derive(Debug)]
-pub enum ConnectedResponse {
-    Announce(AnnounceResponse),
-    Scrape {
-        response: ScrapeResponse,
-        /// Currently only used by glommio implementation
-        original_indices: Vec<usize>,
-    },
-}
-
-impl Into<Response> for ConnectedResponse {
-    fn into(self) -> Response {
-        match self {
-            Self::Announce(response) => Response::Announce(response),
-            Self::Scrape { response, .. } => Response::Scrape(response),
-        }
-    }
-}
-
 pub trait Ip: Hash + PartialEq + Eq + Clone + Copy {
     fn ip_addr(self) -> IpAddr;
 }
@@ -63,6 +34,89 @@ impl Ip for Ipv6Addr {
     }
 }
 
+#[derive(Debug)]
+pub enum ConnectedRequest {
+    Announce(AnnounceRequest),
+    Scrape {
+        request: ScrapeRequest,
+        /// Currently only used by glommio implementation
+        original_indices: Vec<usize>,
+    },
+}
+
+#[derive(Debug)]
+pub enum ConnectedResponse {
+    AnnounceIpv4(AnnounceResponseIpv4),
+    AnnounceIpv6(AnnounceResponseIpv6),
+    Scrape {
+        response: ScrapeResponse,
+        /// Currently only used by glommio implementation
+        original_indices: Vec<usize>,
+    },
+}
+
+impl Into<Response> for ConnectedResponse {
+    fn into(self) -> Response {
+        match self {
+            Self::AnnounceIpv4(response) => Response::AnnounceIpv4(response),
+            Self::AnnounceIpv6(response) => Response::AnnounceIpv6(response),
+            Self::Scrape { response, .. } => Response::Scrape(response),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct ProtocolResponsePeer<I> {
+    pub ip_address: I,
+    pub port: Port,
+}
+
+pub struct ProtocolAnnounceResponse<I> {
+    pub transaction_id: TransactionId,
+    pub announce_interval: AnnounceInterval,
+    pub leechers: NumberOfPeers,
+    pub seeders: NumberOfPeers,
+    pub peers: Vec<ProtocolResponsePeer<I>>,
+}
+
+impl Into<ConnectedResponse> for ProtocolAnnounceResponse<Ipv4Addr> {
+    fn into(self) -> ConnectedResponse {
+        ConnectedResponse::AnnounceIpv4(AnnounceResponseIpv4 {
+            transaction_id: self.transaction_id,
+            announce_interval: self.announce_interval,
+            leechers: self.leechers,
+            seeders: self.seeders,
+            peers: self
+                .peers
+                .into_iter()
+                .map(|peer| ResponsePeerIpv4 {
+                    ip_address: peer.ip_address,
+                    port: peer.port,
+                })
+                .collect(),
+        })
+    }
+}
+
+impl Into<ConnectedResponse> for ProtocolAnnounceResponse<Ipv6Addr> {
+    fn into(self) -> ConnectedResponse {
+        ConnectedResponse::AnnounceIpv6(AnnounceResponseIpv6 {
+            transaction_id: self.transaction_id,
+            announce_interval: self.announce_interval,
+            leechers: self.leechers,
+            seeders: self.seeders,
+            peers: self
+                .peers
+                .into_iter()
+                .map(|peer| ResponsePeerIpv6 {
+                    ip_address: peer.ip_address,
+                    port: peer.port,
+                })
+                .collect(),
+        })
+    }
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
 pub enum PeerStatus {
     Seeding,
@@ -96,9 +150,9 @@ pub struct Peer<I: Ip> {
 
 impl<I: Ip> Peer<I> {
     #[inline(always)]
-    pub fn to_response_peer(&self) -> ResponsePeer {
-        ResponsePeer {
-            ip_address: self.ip_address.ip_addr(),
+    pub fn to_response_peer(&self) -> ProtocolResponsePeer<I> {
+        ProtocolResponsePeer {
+            ip_address: self.ip_address,
             port: self.port,
         }
     }
@@ -230,7 +284,7 @@ pub fn ip_version_from_ip(ip: IpAddr) -> IpVersion {
 
 #[cfg(test)]
 mod tests {
-    use std::net::{IpAddr, Ipv6Addr};
+    use std::net::Ipv6Addr;
 
     use crate::{common::MAX_PACKET_SIZE, config::Config};
 
@@ -263,14 +317,14 @@ mod tests {
 
         let config = Config::default();
 
-        let peers = ::std::iter::repeat(ResponsePeer {
-            ip_address: IpAddr::V6(Ipv6Addr::new(1, 1, 1, 1, 1, 1, 1, 1)),
+        let peers = ::std::iter::repeat(ResponsePeerIpv6 {
+            ip_address: Ipv6Addr::new(1, 1, 1, 1, 1, 1, 1, 1),
             port: Port(1),
         })
         .take(config.protocol.max_response_peers)
         .collect();
 
-        let response = Response::Announce(AnnounceResponse {
+        let response = Response::AnnounceIpv6(AnnounceResponseIpv6 {
             transaction_id: TransactionId(1),
             announce_interval: AnnounceInterval(1),
             seeders: NumberOfPeers(1),
@@ -280,7 +334,7 @@ mod tests {
 
         let mut buf = Vec::new();
 
-        response.write(&mut buf, IpVersion::IPv6).unwrap();
+        response.write(&mut buf).unwrap();
 
         println!("Buffer len: {}", buf.len());
 

aquatic_udp/src/lib/handlers.rs

@@ -79,7 +79,7 @@ pub fn run_request_worker(
                     peer_valid_until,
                 );
 
-                (ConnectedResponse::Announce(response), src)
+                (response, src)
             }));
 
             responses.extend(scrape_requests.drain(..).map(|(request, src)| {
@@ -107,8 +107,8 @@ pub fn handle_announce_request(
     request: AnnounceRequest,
     src: SocketAddr,
     peer_valid_until: ValidUntil,
-) -> AnnounceResponse {
-    match convert_ipv4_mapped_ipv6(src.ip()) {
+) -> ConnectedResponse {
+    match src.ip() {
         IpAddr::V4(ip) => handle_announce_request_inner(
             config,
             rng,
@@ -116,7 +116,8 @@ pub fn handle_announce_request(
             request,
             ip,
             peer_valid_until,
-        ),
+        )
+        .into(),
         IpAddr::V6(ip) => handle_announce_request_inner(
             config,
             rng,
@@ -124,7 +125,8 @@ pub fn handle_announce_request(
             request,
             ip,
             peer_valid_until,
-        ),
+        )
+        .into(),
     }
 }
 
@@ -135,7 +137,7 @@ fn handle_announce_request_inner<I: Ip>(
     request: AnnounceRequest,
     peer_ip: I,
     peer_valid_until: ValidUntil,
-) -> AnnounceResponse {
+) -> ProtocolAnnounceResponse<I> {
     let peer_key = PeerMapKey {
         ip: peer_ip,
         peer_id: request.peer_id,
@@ -186,7 +188,7 @@ fn handle_announce_request_inner<I: Ip>(
         Peer::to_response_peer,
     );
 
-    AnnounceResponse {
+    ProtocolAnnounceResponse {
         transaction_id: request.transaction_id,
         announce_interval: AnnounceInterval(config.protocol.peer_announce_interval),
         leechers: NumberOfPeers(torrent_data.num_leechers as i32),

aquatic_udp/src/lib/network_mio.rs

@@ -1,5 +1,5 @@
 use std::io::{Cursor, ErrorKind};
-use std::net::SocketAddr;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
     Arc,
@@ -128,6 +128,22 @@ fn read_requests(
                     requests_received += 1;
                 }
 
+                let src = match src {
+                    SocketAddr::V6(src) => {
+                        match src.ip().octets() {
+                            // Convert IPv4-mapped address (available in std but nightly-only)
+                            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
+                                SocketAddr::V4(SocketAddrV4::new(
+                                    Ipv4Addr::new(a, b, c, d),
+                                    src.port(),
+                                ))
+                            }
+                            _ => src.into(),
+                        }
+                    }
+                    src => src,
+                };
+
                 handle_request(
                     config,
                     connections,
@@ -182,16 +198,31 @@ fn send_responses(
             .map(|(response, addr)| (response.into(), addr)),
     );
 
-    for (response, src) in response_iterator {
+    for (response, addr) in response_iterator {
         cursor.set_position(0);
 
-        let ip_version = ip_version_from_ip(src.ip());
+        let addr = if config.network.address.is_ipv4() {
+            if let SocketAddr::V4(addr) = addr {
+                SocketAddr::V4(addr)
+            } else {
+                unreachable!()
+            }
+        } else {
+            match addr {
+                SocketAddr::V4(addr) => {
+                    let ip = addr.ip().to_ipv6_mapped();
 
-        match response.write(&mut cursor, ip_version) {
+                    SocketAddr::V6(SocketAddrV6::new(ip, addr.port(), 0, 0))
+                }
+                addr => addr,
+            }
+        };
+
+        match response.write(&mut cursor) {
             Ok(()) => {
                 let amt = cursor.position() as usize;
 
-                match socket.send_to(&cursor.get_ref()[..amt], src) {
+                match socket.send_to(&cursor.get_ref()[..amt], addr) {
                     Ok(amt) => {
                         responses_sent += 1;
                         bytes_sent += amt;

aquatic_udp/src/lib/network_uring.rs

@@ -215,7 +215,7 @@ pub fn run_socket_worker(
                         let buffer_index = user_data.get_buffer_index();
                         let buffer_len = result as usize;
 
-                        let addr = if config.network.address.is_ipv4() {
+                        let src = if config.network.address.is_ipv4() {
                             SocketAddr::V4(SocketAddrV4::new(
                                 Ipv4Addr::from(u32::from_be(
                                     sockaddrs_ipv4[buffer_index].sin_addr.s_addr,
@@ -258,7 +258,7 @@ pub fn run_socket_worker(
                             &mut local_responses,
                             valid_until,
                             res_request,
-                            addr,
+                            src,
                         );
                     }
                 }
@@ -397,7 +397,7 @@ fn queue_response(
 
     let mut cursor = Cursor::new(&mut buffers[buffer_index][..]);
 
-    match response.write(&mut cursor, ip_version_from_ip(addr.ip())) {
+    match response.write(&mut cursor) {
         Ok(()) => {
             iovs[buffer_index].iov_len = cursor.position() as usize;