1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Module containing structs for working with network addresses
//!
//! This also provides the serialization and deserialization of network addresses
use serde::{Deserialize, Serialize, Serializer, Deserializer};
use std::net::{Ipv4Addr, SocketAddr, IpAddr};
use serde::ser::SerializeTuple;
use serde::de::{Visitor, SeqAccess};
use std::fmt;

/// Wrapper for a SocketAddr. Had to be wrapped to serialize it properly
/// Currently this can only be used as an IPV4 address + port
#[derive(Debug, PartialEq)]
pub struct Address(pub SocketAddr);

impl Serialize for Address {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let v4 = match self.0.ip() {
            IpAddr::V4(a) => a,
            IpAddr::V6(_) => {
                return Err(serde::ser::Error::custom(
                    "ip-v8 does not (yet) support ipv6",
                ))
            }
        };

        let mut state = serializer.serialize_tuple(2)?;
        state.serialize_element(&v4)?;
        state.serialize_element(&self.0.port())?;
        state.end()
    }
}

impl<'de> Deserialize<'de> for Address {
    /// deserializes a Header
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // first deserialize it to a temporary struct which literally represents the packer
        #[doc(hidden)]
        struct AddressVistor;
        impl<'de> Visitor<'de> for AddressVistor {
            type Value = Address;
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("Address")
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: SeqAccess<'de>,
            {
                let addr: Ipv4Addr = seq
                    .next_element()?
                    .ok_or_else(|| serde::de::Error::custom("Could not deserialize the address"))?;
                let port: u16 = seq
                    .next_element()?
                    .ok_or_else(|| serde::de::Error::custom("Could not deserialize the port"))?;

                Ok(Address(SocketAddr::new(IpAddr::V4(addr), port)))
            }
        }

        Ok(deserializer.deserialize_tuple(2, AddressVistor)?)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use bincode;
    use std::net::{SocketAddr, IpAddr};

    #[test]
    fn test_serialization() {
        let i = Address(SocketAddr::new(
            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
            8000,
        ));

        assert_eq!(bincode::serialize(&i).unwrap(), vec![127, 0, 0, 1, 64, 31]);
    }

    #[test]
    fn test_deserialization() {
        let i = Address(SocketAddr::new(
            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
            4242,
        ));

        assert_eq!(
            i,
            bincode::deserialize(&bincode::serialize(&i).unwrap()).unwrap()
        );
    }
}