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#[derive(Debug, Default, Clone, PartialEq)]
26pub struct CompactIpv4Addrs(Vec<CompactIpv4Addr>);
27
28impl CompactIpv4Addrs {
29 pub fn is_empty(&self) -> bool {
31 self.0.is_empty()
32 }
33
34 pub fn iter(&self) -> impl Iterator<Item = &CompactIpv4Addr> {
36 self.0.iter()
37 }
38
39 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#[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 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#[derive(Debug, Default, Clone, PartialEq)]
277pub struct CompactIpv6Addrs(Vec<CompactIpv6Addr>);
278
279impl CompactIpv6Addrs {
280 pub fn is_empty(&self) -> bool {
282 self.0.is_empty()
283 }
284
285 pub fn iter(&self) -> impl Iterator<Item = &CompactIpv6Addr> {
287 self.0.iter()
288 }
289
290 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#[derive(Debug, Clone, PartialEq)]
392pub struct CompactIpv6Addr {
393 pub ip: Ipv6Addr,
394 pub port: u16,
395}
396
397impl CompactIpv6Addr {
398 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#[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#[derive(Debug, Clone, PartialEq)]
620pub enum CompactIpAddr {
621 IPv4(CompactIpv4Addr),
622 IPv6(CompactIpv6Addr),
623}
624
625impl CompactIpAddr {
626 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}