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!("Could not find '/' delimiter in the address {s:?}"));
73            }
74        };
75
76        let addr = match SocketAddr::from_str(addr) {
77            Ok(addr) => addr,
78            Err(_) => return Err(format!("Failed to parse IP:PORT {addr:?}")),
79        };
80
81        if proto.eq_ignore_ascii_case("tcp") {
82            Ok(PeerAddr::Tcp(addr))
83        } else if proto.eq_ignore_ascii_case("quic") {
84            Ok(PeerAddr::Quic(addr))
85        } else {
86            Err(format!("Unrecognized protocol {proto:?} in {s:?}"))
87        }
88    }
89}
90
91impl fmt::Display for PeerAddr {
92    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
93        match self {
94            Self::Tcp(addr) => write!(f, "tcp/{addr}"),
95            Self::Quic(addr) => write!(f, "quic/{addr}"),
96        }
97    }
98}
99
100impl Serialize for PeerAddr {
101    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
102    where
103        S: Serializer,
104    {
105        if s.is_human_readable() {
106            self.to_string().serialize(s)
107        } else {
108            SerdeProxy::serialize(self, s)
109        }
110    }
111}
112
113impl<'de> Deserialize<'de> for PeerAddr {
114    fn deserialize<D>(d: D) -> Result<Self, D::Error>
115    where
116        D: Deserializer<'de>,
117    {
118        if d.is_human_readable() {
119            <&str>::deserialize(d)?.parse().map_err(D::Error::custom)
120        } else {
121            SerdeProxy::deserialize(d)
122        }
123    }
124}
125
126// Proxy to serialize/deserialize PeerAddr in non human-readable formats.
127#[derive(Serialize, Deserialize)]
128#[serde(remote = "PeerAddr")]
129enum SerdeProxy {
130    Tcp(#[allow(dead_code)] SocketAddr),
131    Quic(#[allow(dead_code)] SocketAddr),
132}
133
134#[cfg(test)]
135mod tests {
136    use super::*;
137    use std::net::{Ipv4Addr, Ipv6Addr};
138
139    #[test]
140    fn parse() {
141        for (orig, expected) in [
142            (
143                PeerAddr::Tcp((Ipv4Addr::UNSPECIFIED, 0).into()),
144                "tcp/0.0.0.0:0",
145            ),
146            (
147                PeerAddr::Tcp((Ipv6Addr::UNSPECIFIED, 0).into()),
148                "tcp/[::]:0",
149            ),
150            (
151                PeerAddr::Quic((Ipv4Addr::UNSPECIFIED, 0).into()),
152                "quic/0.0.0.0:0",
153            ),
154            (
155                PeerAddr::Quic((Ipv6Addr::UNSPECIFIED, 0).into()),
156                "quic/[::]:0",
157            ),
158        ] {
159            assert_eq!(orig.to_string(), expected);
160            assert_eq!(expected.parse::<PeerAddr>().unwrap(), orig);
161        }
162    }
163
164    #[test]
165    fn serialize_binary() {
166        for (orig, expected) in [
167            (
168                PeerAddr::Tcp(([192, 0, 2, 0], 12481).into()),
169                "0000000000000000c0000200c130",
170            ),
171            (
172                PeerAddr::Quic(([0x2001, 0xdb8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5], 24816).into()),
173                "010000000100000020010db8000000010002000300040005f060",
174            ),
175        ] {
176            assert_eq!(hex::encode(bincode::serialize(&orig).unwrap()), expected);
177            assert_eq!(
178                bincode::deserialize::<PeerAddr>(&hex::decode(expected).unwrap()).unwrap(),
179                orig
180            );
181        }
182    }
183
184    #[test]
185    fn serialize_human_readable() {
186        for addr in [
187            PeerAddr::Tcp(([192, 0, 2, 0], 12481).into()),
188            PeerAddr::Quic(([0x2001, 0xdb8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5], 24816).into()),
189        ] {
190            let expected = addr.to_string();
191            let actual = serde_json::to_string(&addr).unwrap();
192            assert_eq!(actual, format!("\"{expected}\""))
193        }
194    }
195}
ouisync/network/peer_addr.rs

ouisync/network/
peer_addr.rs
