aquatic_http: add ipv6 compact responses; fix ipv4/ipv6 issue

aquatic_http/src/lib/protocol/response.rs

@@ -1,4 +1,4 @@
-use std::net::IpAddr;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 use hashbrown::HashMap;
 use serde::Serialize;
@@ -9,7 +9,6 @@ use super::common::*;
 use super::utils::*;
 
 
-#[derive(Clone, Copy, Debug, Serialize)]
 pub struct ResponsePeer {
     pub ip_address: IpAddr,
     pub port: u16
@@ -28,6 +27,36 @@ impl ResponsePeer {
 }
 
 
+#[derive(Clone, Copy, Debug, Serialize)]
+pub struct ResponsePeerV4 {
+    pub ip_address: Ipv4Addr,
+    pub port: u16
+}
+
+
+#[derive(Clone, Copy, Debug, Serialize)]
+pub struct ResponsePeerV6 {
+    pub ip_address: Ipv6Addr,
+    pub port: u16
+}
+
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(transparent)]
+pub struct ResponsePeerListV4(
+    #[serde(serialize_with = "serialize_response_peers_ipv4")]
+    pub Vec<ResponsePeerV4>
+);
+
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(transparent)]
+pub struct ResponsePeerListV6(
+    #[serde(serialize_with = "serialize_response_peers_ipv6")]
+    pub Vec<ResponsePeerV6>
+);
+
+
 #[derive(Debug, Clone, Serialize)]
 pub struct ScrapeStatistics {
     pub complete: usize,
@@ -42,10 +71,8 @@ pub struct AnnounceResponse {
     pub announce_interval: usize,
     pub complete: usize,
     pub incomplete: usize,
-    #[serde(
-        serialize_with = "serialize_response_peers_compact"
-    )]
-    pub peers: Vec<ResponsePeer>,
+    pub peers: ResponsePeerListV4,
+    pub peers6: ResponsePeerListV6,
 }
 
 

aquatic_http/src/lib/protocol/utils.rs

@@ -1,8 +1,6 @@
-use std::net::IpAddr;
-
 use serde::Serializer;
 
-use super::response::ResponsePeer;
+use super::response::{ResponsePeerV4, ResponsePeerV6};
 
 
 /// Not for serde
@@ -42,22 +40,30 @@ pub fn serialize_20_bytes<S>(
 }
 
 
-pub fn serialize_response_peers_compact<S>(
-    response_peers: &[ResponsePeer],
+pub fn serialize_response_peers_ipv4<S>(
+    response_peers: &[ResponsePeerV4],
     serializer: S
 ) -> Result<S::Ok, S::Error> where S: Serializer {
     let mut bytes = Vec::with_capacity(response_peers.len() * 6);
 
     for peer in response_peers {
-        match peer.ip_address {
-            IpAddr::V4(ip) => {
-                bytes.extend_from_slice(&u32::from(ip).to_be_bytes());
-                bytes.extend_from_slice(&peer.port.to_be_bytes())
-            },
-            IpAddr::V6(_) => {
-                continue;
-            }
-        }
+        bytes.extend_from_slice(&u32::from(peer.ip_address).to_be_bytes());
+        bytes.extend_from_slice(&peer.port.to_be_bytes())
+    }
+
+    serializer.serialize_bytes(&bytes)
+}
+
+
+pub fn serialize_response_peers_ipv6<S>(
+    response_peers: &[ResponsePeerV6],
+    serializer: S
+) -> Result<S::Ok, S::Error> where S: Serializer {
+    let mut bytes = Vec::with_capacity(response_peers.len() * 6);
+
+    for peer in response_peers {
+        bytes.extend_from_slice(&u128::from(peer.ip_address).to_be_bytes());
+        bytes.extend_from_slice(&peer.port.to_be_bytes())
     }
 
     serializer.serialize_bytes(&bytes)