Skip to main content

fx_torrent/
compact.rs

1use base64::prelude::BASE64_STANDARD;
2use base64::Engine;
3use itertools::Itertools;
4use log::warn;
5use serde::de::{SeqAccess, Visitor};
6use serde::{Deserialize, Deserializer, Serialize, Serializer};
7use std::fmt::Formatter;
8use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
9use thiserror::Error;
10
11pub(crate) const COMPACT_IPV4_ADDR_LEN: usize = 6;
12pub(crate) const COMPACT_IPV6_ADDR_LEN: usize = 18;
13
14#[derive(Debug, Error)]
15pub enum CompactError {
16    #[error("invalid compact ip address byte slice")]
17    InvalidLength,
18    #[error("failed to parse compact ip address, {0}")]
19    AddressParse(String),
20}
21
22pub type CompactResult<T> = Result<T, CompactError>;
23
24/// A list of compact IPv4 addresses
25#[derive(Debug, Default, Clone, PartialEq)]
26pub struct CompactIpv4Addrs(Vec<CompactIpv4Addr>);
27
28impl CompactIpv4Addrs {
29    /// Returns true if the addresses are empty.
30    pub fn is_empty(&self) -> bool {
31        self.0.is_empty()
32    }
33
34    /// Returns an iterator over the compact ipv4 addresses.
35    pub fn iter(&self) -> impl Iterator<Item = &CompactIpv4Addr> {
36        self.0.iter()
37    }
38
39    /// Creates a consuming iterator, that is, one that moves each value out of the vector (from start to end). The vector cannot be used after calling this.
40    pub fn into_iter(self) -> impl Iterator<Item = CompactIpv4Addr> {
41        self.0.into_iter()
42    }
43}
44
45impl Serialize for CompactIpv4Addrs {
46    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
47    where
48        S: Serializer,
49    {
50        let bytes: Vec<u8> = self.0.iter().map(|e| e.as_bytes()).concat();
51        serializer.serialize_bytes(bytes.as_slice())
52    }
53}
54
55impl<'de> Deserialize<'de> for CompactIpv4Addrs {
56    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
57    where
58        D: Deserializer<'de>,
59    {
60        struct CompactIpv4AddrsVisitor;
61        impl<'de> Visitor<'de> for CompactIpv4AddrsVisitor {
62            type Value = CompactIpv4Addrs;
63
64            fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
65                write!(
66                    f,
67                    "expected a string, sequence or byte array of compact ipv4 addresses"
68                )
69            }
70
71            fn visit_str<E>(self, v: &str) -> std::result::Result<Self::Value, E>
72            where
73                E: serde::de::Error,
74            {
75                let value = BASE64_STANDARD
76                    .decode(v)
77                    .map_err(|e| serde::de::Error::custom(e.to_string()))?;
78
79                CompactIpv4Addrs::try_from(value.as_slice())
80                    .map_err(|e| serde::de::Error::custom(e.to_string()))
81            }
82
83            fn visit_bytes<E>(self, v: &[u8]) -> std::result::Result<Self::Value, E>
84            where
85                E: serde::de::Error,
86            {
87                CompactIpv4Addrs::try_from(v).map_err(|e| serde::de::Error::custom(e.to_string()))
88            }
89
90            fn visit_seq<A>(self, mut seq: A) -> std::result::Result<Self::Value, A::Error>
91            where
92                A: SeqAccess<'de>,
93            {
94                let mut addrs = Vec::new();
95
96                while let Ok(Some(addr)) = seq.next_element::<CompactIpv4Addr>() {
97                    addrs.push(addr);
98                }
99
100                Ok(Self::Value::from(addrs))
101            }
102        }
103
104        deserializer.deserialize_any(CompactIpv4AddrsVisitor {})
105    }
106}
107
108impl From<Vec<CompactIpv4Addr>> for CompactIpv4Addrs {
109    fn from(addrs: Vec<CompactIpv4Addr>) -> Self {
110        Self(addrs)
111    }
112}
113
114impl TryFrom<&[u8]> for CompactIpv4Addrs {
115    type Error = CompactError;
116
117    fn try_from(bytes: &[u8]) -> CompactResult<Self> {
118        if bytes.len() % COMPACT_IPV4_ADDR_LEN != 0 {
119            return Err(CompactError::InvalidLength);
120        }
121
122        let mut addrs = Vec::new();
123        let addr_count = bytes.len() / COMPACT_IPV4_ADDR_LEN;
124        for i in 0..addr_count {
125            let start = i * COMPACT_IPV4_ADDR_LEN;
126            let end = start + COMPACT_IPV4_ADDR_LEN;
127
128            match CompactIpv4AddrVisitor::parse_bytes(&bytes[start..end]) {
129                Ok(addr) => addrs.push(addr),
130                Err(e) => warn!("Failed to parse compact address, {}", e),
131            }
132        }
133
134        Ok(Self(addrs))
135    }
136}
137
138/// A compact IPv4 address of a torrent peer.
139#[derive(Debug, Clone, PartialEq)]
140pub struct CompactIpv4Addr {
141    pub ip: Ipv4Addr,
142    pub port: u16,
143}
144
145impl CompactIpv4Addr {
146    pub fn as_bytes(&self) -> Vec<u8> {
147        let ip: [u8; 4] = self.ip.octets();
148        let port = self.port.to_be_bytes();
149        let mut bytes = [0u8; COMPACT_IPV4_ADDR_LEN];
150
151        bytes[0..4].copy_from_slice(&ip);
152        bytes[4..].copy_from_slice(&port);
153
154        bytes.to_vec()
155    }
156}
157
158impl Into<SocketAddr> for CompactIpv4Addr {
159    fn into(self) -> SocketAddr {
160        SocketAddr::new(IpAddr::V4(self.ip), self.port)
161    }
162}
163
164impl Into<IpAddr> for CompactIpv4Addr {
165    fn into(self) -> IpAddr {
166        IpAddr::V4(self.ip)
167    }
168}
169
170impl From<&CompactIpv4Addr> for IpAddr {
171    fn from(addr: &CompactIpv4Addr) -> Self {
172        IpAddr::V4(addr.ip)
173    }
174}
175
176impl From<&CompactIpv4Addr> for SocketAddr {
177    fn from(value: &CompactIpv4Addr) -> Self {
178        SocketAddr::new(IpAddr::V4(value.ip), value.port)
179    }
180}
181
182impl TryFrom<&[u8]> for CompactIpv4Addr {
183    type Error = CompactError;
184
185    fn try_from(bytes: &[u8]) -> CompactResult<Self> {
186        CompactIpv4AddrVisitor::parse_bytes(bytes)
187    }
188}
189
190impl TryFrom<SocketAddr> for CompactIpv4Addr {
191    type Error = CompactError;
192
193    fn try_from(addr: SocketAddr) -> CompactResult<Self> {
194        if let IpAddr::V4(ip) = addr.ip() {
195            Ok(Self {
196                ip,
197                port: addr.port(),
198            })
199        } else {
200            Err(CompactError::AddressParse(
201                "IPv6 is not supported for CompactIpv4Addr".to_string(),
202            ))
203        }
204    }
205}
206
207impl From<&CompactIpv4Addr> for [u8; COMPACT_IPV4_ADDR_LEN] {
208    fn from(value: &CompactIpv4Addr) -> [u8; COMPACT_IPV4_ADDR_LEN] {
209        let ip: [u8; 4] = value.ip.octets();
210        let port = value.port.to_be_bytes();
211        let mut bytes = [0u8; COMPACT_IPV4_ADDR_LEN];
212
213        bytes[0..4].copy_from_slice(&ip);
214        bytes[4..].copy_from_slice(&port);
215
216        bytes
217    }
218}
219
220impl Serialize for CompactIpv4Addr {
221    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
222    where
223        S: Serializer,
224    {
225        let bytes: [u8; 6] = self.into();
226        serializer.serialize_bytes(bytes.as_slice())
227    }
228}
229
230impl<'de> Deserialize<'de> for CompactIpv4Addr {
231    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
232    where
233        D: Deserializer<'de>,
234    {
235        deserializer.deserialize_bytes(CompactIpv4AddrVisitor {})
236    }
237}
238
239struct CompactIpv4AddrVisitor;
240
241impl CompactIpv4AddrVisitor {
242    /// Parse a single compact IPv4 address from the given bytes.
243    fn parse_bytes(bytes: &[u8]) -> CompactResult<CompactIpv4Addr> {
244        if bytes.len() != COMPACT_IPV4_ADDR_LEN {
245            return Err(CompactError::AddressParse(
246                "expected a byte slice of a compact ipv4 address".to_string(),
247            ));
248        }
249
250        let ip = Ipv4Addr::new(bytes[0], bytes[1], bytes[2], bytes[3]);
251        let port = u16::from_be_bytes([bytes[4], bytes[5]]);
252        Ok(CompactIpv4Addr { ip, port })
253    }
254}
255
256impl<'de> Visitor<'de> for CompactIpv4AddrVisitor {
257    type Value = CompactIpv4Addr;
258
259    fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
260        write!(f, "expected a byte slice of a compact ipv4 address")
261    }
262
263    fn visit_bytes<E>(self, v: &[u8]) -> std::result::Result<Self::Value, E>
264    where
265        E: serde::de::Error,
266    {
267        if v.len() != 6 {
268            return Err(serde::de::Error::invalid_length(v.len(), &self));
269        }
270
271        Self::parse_bytes(v).map_err(|e| serde::de::Error::custom(e))
272    }
273}
274
275/// A list of compact IPv6 addresses
276#[derive(Debug, Default, Clone, PartialEq)]
277pub struct CompactIpv6Addrs(Vec<CompactIpv6Addr>);
278
279impl CompactIpv6Addrs {
280    /// Returns true if the addresses are empty.
281    pub fn is_empty(&self) -> bool {
282        self.0.is_empty()
283    }
284
285    /// Returns an iterator over the ipv6 compact addresses.
286    pub fn iter(&self) -> impl Iterator<Item = &CompactIpv6Addr> {
287        self.0.iter()
288    }
289
290    /// Creates a consuming iterator, that is, one that moves each value out of the vector (from start to end).
291    /// The compact addresses cannot be used after calling this.
292    pub fn into_iter(self) -> impl Iterator<Item = CompactIpv6Addr> {
293        self.0.into_iter()
294    }
295}
296
297impl Serialize for CompactIpv6Addrs {
298    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
299    where
300        S: Serializer,
301    {
302        let bytes: Vec<u8> = self.0.iter().map(|e| e.as_bytes()).concat();
303        serializer.serialize_bytes(bytes.as_slice())
304    }
305}
306
307impl<'de> Deserialize<'de> for CompactIpv6Addrs {
308    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
309    where
310        D: Deserializer<'de>,
311    {
312        struct CompactIpv6AddrsVisitor;
313        impl<'de> Visitor<'de> for CompactIpv6AddrsVisitor {
314            type Value = CompactIpv6Addrs;
315
316            fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
317                write!(
318                    f,
319                    "expected a string, sequence or byte array of compact ipv6 addresses"
320                )
321            }
322
323            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
324            where
325                E: serde::de::Error,
326            {
327                let value = BASE64_STANDARD
328                    .decode(v)
329                    .map_err(|e| serde::de::Error::custom(e.to_string()))?;
330
331                Self::Value::try_from(value.as_slice())
332                    .map_err(|e| serde::de::Error::custom(e.to_string()))
333            }
334
335            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
336            where
337                E: serde::de::Error,
338            {
339                Self::Value::try_from(v).map_err(|e| serde::de::Error::custom(e.to_string()))
340            }
341
342            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
343            where
344                A: SeqAccess<'de>,
345            {
346                let mut addrs = Vec::new();
347
348                while let Ok(Some(addr)) = seq.next_element::<CompactIpv6Addr>() {
349                    addrs.push(addr);
350                }
351
352                Ok(Self::Value::from(addrs))
353            }
354        }
355
356        deserializer.deserialize_any(CompactIpv6AddrsVisitor)
357    }
358}
359
360impl From<Vec<CompactIpv6Addr>> for CompactIpv6Addrs {
361    fn from(addrs: Vec<CompactIpv6Addr>) -> Self {
362        Self(addrs)
363    }
364}
365
366impl TryFrom<&[u8]> for CompactIpv6Addrs {
367    type Error = CompactError;
368
369    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
370        if bytes.len() % COMPACT_IPV6_ADDR_LEN != 0 {
371            return Err(CompactError::InvalidLength);
372        }
373
374        let mut addrs = Vec::new();
375        let addr_count = bytes.len() / COMPACT_IPV6_ADDR_LEN;
376        for i in 0..addr_count {
377            let start = i * COMPACT_IPV6_ADDR_LEN;
378            let end = start + COMPACT_IPV6_ADDR_LEN;
379
380            match CompactIpv6AddrVisitor::parse_bytes(&bytes[start..end]) {
381                Ok(addr) => addrs.push(addr),
382                Err(e) => warn!("Failed to parse compact address, {}", e),
383            }
384        }
385
386        Ok(Self(addrs))
387    }
388}
389
390/// A compact IPv6 address
391#[derive(Debug, Clone, PartialEq)]
392pub struct CompactIpv6Addr {
393    pub ip: Ipv6Addr,
394    pub port: u16,
395}
396
397impl CompactIpv6Addr {
398    /// Returns the bytes representing this compact ipv6 address.
399    pub fn as_bytes(&self) -> Vec<u8> {
400        let ip: [u8; 16] = self.ip.octets();
401        let port = self.port.to_be_bytes();
402        let mut bytes = [0u8; COMPACT_IPV6_ADDR_LEN];
403
404        bytes[..16].copy_from_slice(&ip);
405        bytes[16..].copy_from_slice(&port);
406
407        bytes.to_vec()
408    }
409}
410
411impl Into<SocketAddr> for CompactIpv6Addr {
412    fn into(self) -> SocketAddr {
413        SocketAddr::new(IpAddr::V6(self.ip), self.port)
414    }
415}
416
417impl Into<IpAddr> for CompactIpv6Addr {
418    fn into(self) -> IpAddr {
419        IpAddr::V6(self.ip)
420    }
421}
422
423impl TryInto<CompactIpv6Addr> for SocketAddr {
424    type Error = CompactError;
425
426    fn try_into(self) -> CompactResult<CompactIpv6Addr> {
427        let ip_addr = self.ip();
428
429        match ip_addr {
430            IpAddr::V6(addr) => Ok(CompactIpv6Addr {
431                ip: addr,
432                port: self.port(),
433            }),
434            IpAddr::V4(_) => Err(CompactError::AddressParse(
435                "expected ipv6, but got ipv4 instead".to_string(),
436            )),
437        }
438    }
439}
440
441impl From<&CompactIpv6Addr> for IpAddr {
442    fn from(addr: &CompactIpv6Addr) -> Self {
443        IpAddr::V6(addr.ip)
444    }
445}
446
447impl From<&CompactIpv6Addr> for SocketAddr {
448    fn from(value: &CompactIpv6Addr) -> Self {
449        SocketAddr::new(IpAddr::V6(value.ip), value.port)
450    }
451}
452
453impl TryFrom<&[u8]> for CompactIpv6Addr {
454    type Error = CompactError;
455
456    fn try_from(bytes: &[u8]) -> CompactResult<Self> {
457        CompactIpv6AddrVisitor::parse_bytes(bytes)
458    }
459}
460
461impl From<&CompactIpv6Addr> for [u8; COMPACT_IPV6_ADDR_LEN] {
462    fn from(value: &CompactIpv6Addr) -> [u8; COMPACT_IPV6_ADDR_LEN] {
463        let ip: [u8; 16] = value.ip.octets();
464        let port = value.port.to_be_bytes();
465        let mut bytes = [0u8; COMPACT_IPV6_ADDR_LEN];
466
467        bytes[..16].copy_from_slice(&ip);
468        bytes[16..].copy_from_slice(&port);
469
470        bytes
471    }
472}
473
474impl Serialize for CompactIpv6Addr {
475    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
476    where
477        S: serde::Serializer,
478    {
479        let ip_bytes: [u8; 16] = self.ip.octets();
480        let port_bytes = self.port.to_be_bytes();
481
482        let mut bytes = Vec::with_capacity(COMPACT_IPV6_ADDR_LEN);
483        bytes.extend_from_slice(&ip_bytes);
484        bytes.extend_from_slice(&port_bytes);
485
486        serializer.serialize_bytes(&bytes)
487    }
488}
489
490impl<'de> Deserialize<'de> for CompactIpv6Addr {
491    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
492    where
493        D: Deserializer<'de>,
494    {
495        deserializer.deserialize_bytes(CompactIpv6AddrVisitor {})
496    }
497}
498
499struct CompactIpv6AddrVisitor;
500
501impl CompactIpv6AddrVisitor {
502    fn parse_bytes(bytes: &[u8]) -> CompactResult<CompactIpv6Addr> {
503        if bytes.len() != COMPACT_IPV6_ADDR_LEN {
504            return Err(CompactError::AddressParse(
505                "expected a byte slice of a compact ipv6 address".to_string(),
506            ));
507        }
508
509        let ip_bytes: [u8; 16] = <[u8; 16]>::try_from(&bytes[0..16]).map_err(|_| {
510            CompactError::AddressParse("failed to convert slice to [u8; 16]".to_string())
511        })?;
512        let ip = Ipv6Addr::from(ip_bytes);
513        let port = u16::from_be_bytes([bytes[16], bytes[17]]);
514        Ok(CompactIpv6Addr { ip, port })
515    }
516}
517
518impl<'de> Visitor<'de> for CompactIpv6AddrVisitor {
519    type Value = CompactIpv6Addr;
520
521    fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
522        write!(f, "expected a byte slice of a compact ipv6 address")
523    }
524
525    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
526    where
527        E: serde::de::Error,
528    {
529        if v.len() != 18 {
530            return Err(serde::de::Error::invalid_length(v.len(), &self));
531        }
532
533        Self::parse_bytes(v).map_err(|e| serde::de::Error::custom(e))
534    }
535}
536
537/// A compact representation of an IPv44 or IPv66 address without port.
538#[derive(Debug, Clone, PartialEq)]
539pub struct CompactIp {
540    pub ip: IpAddr,
541}
542
543impl From<IpAddr> for CompactIp {
544    fn from(value: IpAddr) -> Self {
545        Self { ip: value }
546    }
547}
548
549impl From<CompactIp> for IpAddr {
550    fn from(value: CompactIp) -> Self {
551        value.ip
552    }
553}
554
555impl From<&SocketAddr> for CompactIp {
556    fn from(value: &SocketAddr) -> Self {
557        Self { ip: value.ip() }
558    }
559}
560
561impl Serialize for CompactIp {
562    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
563    where
564        S: Serializer,
565    {
566        let bytes: Vec<u8> = match &self.ip {
567            IpAddr::V4(addr) => addr.octets().to_vec(),
568            IpAddr::V6(addr) => addr.octets().to_vec(),
569        };
570
571        serializer.serialize_bytes(&bytes)
572    }
573}
574
575impl<'de> Deserialize<'de> for CompactIp {
576    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
577    where
578        D: Deserializer<'de>,
579    {
580        deserializer.deserialize_bytes(CompactIpVisitor)
581    }
582}
583
584struct CompactIpVisitor;
585
586impl<'de> Visitor<'de> for CompactIpVisitor {
587    type Value = CompactIp;
588
589    fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
590        write!(f, "expected a compact ip address as bytes")
591    }
592
593    fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
594    where
595        E: serde::de::Error,
596    {
597        let addr: IpAddr;
598
599        if bytes.len() == 4 {
600            addr = IpAddr::V4(Ipv4Addr::new(bytes[0], bytes[1], bytes[2], bytes[3]));
601        } else if bytes.len() == 16 {
602            addr = <[u8; 16]>::try_from(&bytes[0..16])
603                .map(|e| Ipv6Addr::from(e))
604                .map(|e| IpAddr::V6(e))
605                .map_err(|_| {
606                    serde::de::Error::custom(CompactError::AddressParse(
607                        "failed to convert slice to [u8; 16]".to_string(),
608                    ))
609                })?;
610        } else {
611            return Err(serde::de::Error::invalid_length(bytes.len(), &self));
612        }
613
614        Ok(CompactIp { ip: addr })
615    }
616}
617
618/// A compact IP address which can either be represented as IPv4 or IPv6.
619#[derive(Debug, Clone, PartialEq)]
620pub enum CompactIpAddr {
621    IPv4(CompactIpv4Addr),
622    IPv6(CompactIpv6Addr),
623}
624
625impl CompactIpAddr {
626    /// Returns the bytes representing this compact ip address.
627    pub fn as_bytes(&self) -> Vec<u8> {
628        match self {
629            CompactIpAddr::IPv4(e) => e.as_bytes(),
630            CompactIpAddr::IPv6(e) => e.as_bytes(),
631        }
632    }
633}
634
635impl Serialize for CompactIpAddr {
636    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
637    where
638        S: Serializer,
639    {
640        match self {
641            CompactIpAddr::IPv4(e) => e.serialize(serializer),
642            CompactIpAddr::IPv6(e) => e.serialize(serializer),
643        }
644    }
645}
646
647impl<'de> Deserialize<'de> for CompactIpAddr {
648    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
649    where
650        D: Deserializer<'de>,
651    {
652        struct CompactIpAddrVisitor;
653        impl<'de> Visitor<'de> for CompactIpAddrVisitor {
654            type Value = CompactIpAddr;
655
656            fn expecting(&self, f: &mut Formatter) -> std::fmt::Result {
657                write!(f, "expected a compact ip address as bytes")
658            }
659
660            fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
661            where
662                E: serde::de::Error,
663            {
664                match bytes.len() {
665                    COMPACT_IPV4_ADDR_LEN => CompactIpv4Addr::try_from(bytes)
666                        .map(CompactIpAddr::IPv4)
667                        .map_err(|e| serde::de::Error::custom(e)),
668                    COMPACT_IPV6_ADDR_LEN => CompactIpv6Addr::try_from(bytes)
669                        .map(CompactIpAddr::IPv6)
670                        .map_err(|e| serde::de::Error::custom(e)),
671                    _ => Err(serde::de::Error::invalid_length(bytes.len(), &self)),
672                }
673            }
674        }
675
676        deserializer.deserialize_bytes(CompactIpAddrVisitor)
677    }
678}
679
680impl From<CompactIpv4Addr> for CompactIpAddr {
681    fn from(value: CompactIpv4Addr) -> Self {
682        Self::IPv4(value)
683    }
684}
685
686impl From<CompactIpv6Addr> for CompactIpAddr {
687    fn from(value: CompactIpv6Addr) -> Self {
688        Self::IPv6(value)
689    }
690}
691
692impl From<SocketAddr> for CompactIpAddr {
693    fn from(value: SocketAddr) -> Self {
694        if value.is_ipv4() {
695            match value.try_into() {
696                Ok(addr) => CompactIpAddr::IPv4(addr),
697                Err(e) => unreachable!("The socket address should be IPv4 compatible, {}", e),
698            }
699        } else {
700            match value.try_into() {
701                Ok(addr) => CompactIpAddr::IPv6(addr),
702                Err(e) => unreachable!("The socket address should be IPv6 compatible, {}", e),
703            }
704        }
705    }
706}
707
708impl From<&CompactIpAddr> for SocketAddr {
709    fn from(value: &CompactIpAddr) -> Self {
710        match value {
711            CompactIpAddr::IPv4(addr) => addr.into(),
712            CompactIpAddr::IPv6(addr) => addr.into(),
713        }
714    }
715}
716
717#[cfg(test)]
718mod tests {
719    use super::*;
720    use crate::bencode;
721
722    #[derive(Debug, Serialize, Deserialize, PartialEq)]
723    struct TestIpv4List {
724        pub text: String,
725        pub addrs: CompactIpv4Addrs,
726    }
727
728    #[derive(Debug, Serialize, Deserialize, PartialEq)]
729    struct TestIpv6List {
730        pub text: String,
731        pub addrs: CompactIpv6Addrs,
732    }
733
734    #[cfg(test)]
735    mod compact_ipv4_addr {
736        use super::*;
737
738        #[test]
739        fn test_addr() {
740            let expected_result = CompactIpv4Addr {
741                ip: Ipv4Addr::new(127, 0, 0, 1),
742                port: 6881,
743            };
744            let bytes = bencode::to_bytes(&expected_result).unwrap();
745
746            let result = bencode::from_bytes::<CompactIpv4Addr>(&bytes).unwrap();
747
748            assert_eq!(expected_result, result);
749        }
750
751        #[test]
752        fn test_try_into_compact_addr() {
753            let socket = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 6881);
754            let result: CompactResult<CompactIpv4Addr> = socket.try_into();
755            assert!(result.is_err(), "expected an error to be returned");
756
757            let expected_result = CompactIpv4Addr {
758                ip: Ipv4Addr::new(127, 0, 0, 1),
759                port: 6881,
760            };
761            let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 6881);
762            let result = CompactIpv4Addr::try_from(socket).unwrap();
763            assert_eq!(expected_result, result);
764        }
765
766        #[test]
767        fn test_mod() {
768            let expected_result = TestIpv4List {
769                text: "test".to_string(),
770                addrs: vec![CompactIpv4Addr {
771                    ip: Ipv4Addr::new(127, 0, 0, 1),
772                    port: 6881,
773                }]
774                .into(),
775            };
776            let bytes = bencode::to_bytes(&expected_result).unwrap();
777
778            let result = bencode::from_bytes::<TestIpv4List>(&bytes).unwrap();
779
780            assert_eq!(expected_result, result);
781        }
782
783        #[test]
784        fn test_byte_slice_from_compact() {
785            let compact_addr = CompactIpv4Addr {
786                ip: Ipv4Addr::new(127, 0, 0, 1),
787                port: 6881,
788            };
789            let expected_result: [u8; 6] = [127, 0, 0, 1, 26, 225];
790
791            let result: [u8; 6] = (&compact_addr).into();
792
793            assert_eq!(expected_result, result);
794        }
795    }
796
797    #[cfg(test)]
798    mod compact_ipv6_addr {
799        use super::*;
800
801        #[test]
802        fn test_compact_ipv6_addr() {
803            let expected_result = CompactIpv6Addr {
804                ip: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1),
805                port: 9090,
806            };
807            let bytes = bencode::to_bytes(&expected_result).unwrap();
808
809            let result = bencode::from_bytes::<CompactIpv6Addr>(&bytes).unwrap();
810
811            assert_eq!(expected_result, result);
812        }
813
814        #[test]
815        fn test_compact_ipv6_mod() {
816            let expected_result = TestIpv6List {
817                text: "test".to_string(),
818                addrs: vec![CompactIpv6Addr {
819                    ip: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1),
820                    port: 9090,
821                }]
822                .into(),
823            };
824            let bytes = bencode::to_bytes(&expected_result).unwrap();
825
826            let result = bencode::from_bytes::<TestIpv6List>(&bytes).unwrap();
827
828            assert_eq!(expected_result, result);
829        }
830    }
831
832    #[cfg(test)]
833    mod compact_ip {
834        use super::*;
835
836        #[test]
837        fn test_serialize() {
838            let expected_result = CompactIp {
839                ip: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
840            };
841            let bytes = bencode::to_bytes(&expected_result).unwrap();
842            let result = bencode::from_bytes(&bytes).unwrap();
843            assert_eq!(expected_result, result);
844
845            let expected_result = CompactIp {
846                ip: IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 16)),
847            };
848            let bytes = bencode::to_bytes(&expected_result).unwrap();
849            let result = bencode::from_bytes(&bytes).unwrap();
850            assert_eq!(expected_result, result);
851        }
852
853        #[test]
854        fn test_from_ip_addr() {
855            let result = CompactIp::from(IpAddr::from(Ipv4Addr::LOCALHOST));
856            assert_eq!(result.ip, IpAddr::V4(Ipv4Addr::LOCALHOST));
857
858            let result = CompactIp::from(IpAddr::from(Ipv6Addr::LOCALHOST));
859            assert_eq!(result.ip, IpAddr::V6(Ipv6Addr::LOCALHOST));
860        }
861    }
862
863    #[test]
864    fn test_compact_ip_addr() {
865        let expected_result = CompactIpAddr::IPv4(CompactIpv4Addr {
866            ip: Ipv4Addr::new(127, 0, 0, 1),
867            port: 9090,
868        });
869        let bytes = bencode::to_bytes(&expected_result).unwrap();
870        let result = bencode::from_bytes::<CompactIpAddr>(&bytes).unwrap();
871        assert_eq!(expected_result, result);
872
873        let expected_result = CompactIpAddr::IPv6(CompactIpv6Addr {
874            ip: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 16),
875            port: 20021,
876        });
877        let bytes = bencode::to_bytes(&expected_result).unwrap();
878        let result = bencode::from_bytes::<CompactIpAddr>(&bytes).unwrap();
879        assert_eq!(expected_result, result);
880    }
881}