ouisync/network/
peer_addr.rs

1use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
2use std::{
3    fmt,
4    net::{IpAddr, SocketAddr},
5    str::FromStr,
6};
7
8#[derive(Clone, Copy, Serialize, Deserialize, Debug)]
9pub enum PeerPort {
10    Tcp(u16),
11    Quic(u16),
12}
13
14#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
15pub enum PeerAddr {
16    Tcp(SocketAddr),
17    Quic(SocketAddr),
18}
19
20impl PeerAddr {
21    pub fn socket_addr(&self) -> &SocketAddr {
22        match self {
23            Self::Tcp(addr) => addr,
24            Self::Quic(addr) => addr,
25        }
26    }
27
28    pub fn ip(&self) -> IpAddr {
29        self.socket_addr().ip()
30    }
31
32    pub fn port(&self) -> u16 {
33        self.socket_addr().port()
34    }
35
36    pub fn set_port(&mut self, port: u16) {
37        match self {
38            Self::Tcp(addr) => addr.set_port(port),
39            Self::Quic(addr) => addr.set_port(port),
40        }
41    }
42
43    pub fn peer_port(&self) -> PeerPort {
44        match self {
45            Self::Tcp(addr) => PeerPort::Tcp(addr.port()),
46            Self::Quic(addr) => PeerPort::Quic(addr.port()),
47        }
48    }
49
50    pub fn is_quic(&self) -> bool {
51        match self {
52            Self::Tcp(_) => false,
53            Self::Quic(_) => true,
54        }
55    }
56
57    pub fn is_tcp(&self) -> bool {
58        match self {
59            Self::Tcp(_) => true,
60            Self::Quic(_) => false,
61        }
62    }
63}
64
65impl FromStr for PeerAddr {
66    type Err = String;
67
68    fn from_str(s: &str) -> Result<Self, Self::Err> {
69        let (proto, addr) = match s.split_once('/') {
70            Some((proto, addr)) => (proto, addr),
71            None => {
72                return Err(format!(
73                    "Could not find '/' delimiter in the address {:?}",
74                    s
75                ));
76            }
77        };
78
79        let addr = match SocketAddr::from_str(addr) {
80            Ok(addr) => addr,
81            Err(_) => return Err(format!("Failed to parse IP:PORT {:?}", addr)),
82        };
83
84        if proto.eq_ignore_ascii_case("tcp") {
85            Ok(PeerAddr::Tcp(addr))
86        } else if proto.eq_ignore_ascii_case("quic") {
87            Ok(PeerAddr::Quic(addr))
88        } else {
89            Err(format!("Unrecognized protocol {:?} in {:?}", proto, s))
90        }
91    }
92}
93
94impl fmt::Display for PeerAddr {
95    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
96        match self {
97            Self::Tcp(addr) => write!(f, "tcp/{}", addr),
98            Self::Quic(addr) => write!(f, "quic/{}", addr),
99        }
100    }
101}
102
103impl Serialize for PeerAddr {
104    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
105    where
106        S: Serializer,
107    {
108        if s.is_human_readable() {
109            self.to_string().serialize(s)
110        } else {
111            SerdeProxy::serialize(self, s)
112        }
113    }
114}
115
116impl<'de> Deserialize<'de> for PeerAddr {
117    fn deserialize<D>(d: D) -> Result<Self, D::Error>
118    where
119        D: Deserializer<'de>,
120    {
121        if d.is_human_readable() {
122            <&str>::deserialize(d)?.parse().map_err(D::Error::custom)
123        } else {
124            SerdeProxy::deserialize(d)
125        }
126    }
127}
128
129// Proxy to serialize/deserialize PeerAddr in non human-readable formats.
130#[derive(Serialize, Deserialize)]
131#[serde(remote = "PeerAddr")]
132enum SerdeProxy {
133    Tcp(#[allow(dead_code)] SocketAddr),
134    Quic(#[allow(dead_code)] SocketAddr),
135}
136
137#[cfg(test)]
138mod tests {
139    use super::*;
140    use std::net::{Ipv4Addr, Ipv6Addr};
141
142    #[test]
143    fn parse() {
144        for (orig, expected) in [
145            (
146                PeerAddr::Tcp((Ipv4Addr::UNSPECIFIED, 0).into()),
147                "tcp/0.0.0.0:0",
148            ),
149            (
150                PeerAddr::Tcp((Ipv6Addr::UNSPECIFIED, 0).into()),
151                "tcp/[::]:0",
152            ),
153            (
154                PeerAddr::Quic((Ipv4Addr::UNSPECIFIED, 0).into()),
155                "quic/0.0.0.0:0",
156            ),
157            (
158                PeerAddr::Quic((Ipv6Addr::UNSPECIFIED, 0).into()),
159                "quic/[::]:0",
160            ),
161        ] {
162            assert_eq!(orig.to_string(), expected);
163            assert_eq!(expected.parse::<PeerAddr>().unwrap(), orig);
164        }
165    }
166
167    #[test]
168    fn serialize_binary() {
169        for (orig, expected) in [
170            (
171                PeerAddr::Tcp(([192, 0, 2, 0], 12481).into()),
172                "0000000000000000c0000200c130",
173            ),
174            (
175                PeerAddr::Quic(([0x2001, 0xdb8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5], 24816).into()),
176                "010000000100000020010db8000000010002000300040005f060",
177            ),
178        ] {
179            assert_eq!(hex::encode(bincode::serialize(&orig).unwrap()), expected);
180            assert_eq!(
181                bincode::deserialize::<PeerAddr>(&hex::decode(expected).unwrap()).unwrap(),
182                orig
183            );
184        }
185    }
186
187    #[test]
188    fn serialize_human_readable() {
189        for addr in [
190            PeerAddr::Tcp(([192, 0, 2, 0], 12481).into()),
191            PeerAddr::Quic(([0x2001, 0xdb8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5], 24816).into()),
192        ] {
193            let expected = addr.to_string();
194            let actual = serde_json::to_string(&addr).unwrap();
195            assert_eq!(actual, format!("\"{}\"", expected))
196        }
197    }
198}
ouisync/network/peer_addr.rs

ouisync/network/
peer_addr.rs
