wireguard_conf/models/interface.rs
1use derive_builder::Builder;
2use either::Either;
3use ipnet::IpNet;
4use itertools::Itertools as _;
5
6use std::fmt;
7use std::net::Ipv4Addr;
8use std::{convert::Infallible, net::IpAddr};
9
10#[cfg(feature = "serde")]
11#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
12use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
13
14use crate::prelude::*;
15
16/// Controls the routing table to which routes are added.
17#[derive(PartialEq, Eq, Clone, Debug, Default)]
18pub enum Table {
19 /// Routing table
20 RoutingTable(usize),
21
22 /// Disables the creation of routes altogether
23 Off,
24
25 /// Adds routes to the default table and enables special handling of default routes.
26 #[default]
27 Auto,
28}
29
30impl fmt::Display for Table {
31 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
32 match self {
33 Table::RoutingTable(n) => write!(f, "{n}"),
34 Table::Off => write!(f, "off"),
35 Table::Auto => write!(f, "auto"),
36 }
37 }
38}
39
40#[cfg(feature = "serde")]
41impl Serialize for Table {
42 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
43 where
44 S: Serializer,
45 {
46 match self {
47 Table::RoutingTable(n) => serializer.serialize_u64(*n as u64),
48 Table::Off => serializer.serialize_str("off"),
49 Table::Auto => serializer.serialize_str("auto"),
50 }
51 }
52}
53
54#[cfg(feature = "serde")]
55impl<'de> Deserialize<'de> for Table {
56 fn deserialize<D>(deserializer: D) -> Result<Table, D::Error>
57 where
58 D: Deserializer<'de>,
59 {
60 struct TableVisitor;
61 impl de::Visitor<'_> for TableVisitor {
62 type Value = Table;
63
64 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
65 formatter.write_str("an routing table value (number, off or auto)")
66 }
67
68 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
69 where
70 E: de::Error,
71 {
72 match value {
73 "off" => Ok(Table::Off),
74 "auto" => Ok(Table::Auto),
75 _ => Err(E::invalid_value(de::Unexpected::Str(value), &self)),
76 }
77 }
78
79 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
80 where
81 E: de::Error,
82 {
83 Ok(Table::RoutingTable(
84 usize::try_from(value).map_err(E::custom)?,
85 ))
86 }
87 }
88
89 deserializer.deserialize_any(TableVisitor)
90 }
91}
92
93/// Struct, that represents complete configuration (contains both `[Interface]` and `[Peer]`
94/// sections).
95///
96/// Use [`InterfaceBuilder`] to create interface.
97///
98/// [Wireguard docs](https://github.com/pirate/wireguard-docs#interface)
99#[must_use]
100#[derive(Clone, Debug, PartialEq, Builder)]
101#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
102#[builder(build_fn(private, name = "fallible_build", error = "Infallible"))]
103pub struct Interface {
104 /// Interface's address.
105 ///
106 /// `/32` and `/128` IP networks will be generated as regular ips (f.e. `1.2.3.4/32` -> `1.2.3.4`)
107 ///
108 /// You can also use [`InterfaceBuilder::add_network()`] to add a single network and
109 /// [`InterfaceBuilder::add_address()`] to add a single address.
110 ///
111 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#address)
112 #[builder(
113 setter(into),
114 default = "vec![IpNet::new_assert(Ipv4Addr::UNSPECIFIED.into(), 0)]"
115 )]
116 pub address: Vec<IpNet>,
117
118 /// Port to listen for incoming VPN connections.
119 ///
120 /// [Wireguard conf](https://github.com/pirate/wireguard-docs#listenport)
121 #[builder(setter(strip_option), default)]
122 pub listen_port: Option<u16>,
123
124 /// Node's private key.
125 ///
126 /// [Wireguard conf](https://github.com/pirate/wireguard-docs#privatekey)
127 #[builder(default = "PrivateKey::random()")]
128 pub private_key: PrivateKey,
129
130 /// The DNS servers to announce to VPN clients via DHCP.
131 ///
132 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#dns-2)
133 #[builder(setter(into, strip_option), default)]
134 pub dns: Vec<String>,
135
136 /// Endpoint.
137 ///
138 /// - `[Interface]` section will have `# Name = <endpoint>` comment at the top.
139 /// - Exported [`Peer`] (via [`Interface::to_peer`]) will have this endpoint.
140 ///
141 /// [Wireguard Docs for `# Name`](https://github.com/pirate/wireguard-docs?tab=readme-ov-file#-name-1);
142 /// [Wireguard Docs for endpoint](https://github.com/pirate/wireguard-docs?tab=readme-ov-file#endpoint)
143 #[builder(setter(into, strip_option), default)]
144 pub endpoint: Option<String>,
145
146 /// Routing table to use for the WireGuard routes.
147 ///
148 /// See [`Table`] for special values.
149 ///
150 /// [Wireguard docs](https://github.com/pirate/wireguard-docs?tab=readme-ov-file#table)
151 #[builder(setter(strip_option), default)]
152 pub table: Option<Table>,
153
154 /// Maximum Transmission Unit (MTU, aka packet/frame size) to use when connecting to the peer.
155 ///
156 /// [Wireguard docs](https://github.com/pirate/wireguard-docs?tab=readme-ov-file#mtu)
157 #[builder(setter(strip_option), default)]
158 pub mtu: Option<usize>,
159
160 /// AmneziaWG obfuscation values.
161 ///
162 /// [AmneziaWG Docs](https://github.com/amnezia-vpn/amneziawg-linux-kernel-module?tab=readme-ov-file#configuration)
163 #[cfg(feature = "amneziawg")]
164 #[cfg_attr(docsrs, doc(cfg(feature = "amneziawg")))]
165 #[builder(setter(strip_option), default)]
166 pub amnezia_settings: Option<AmneziaSettings>,
167
168 /// Commands, that will be executed before the interface is brought up
169 ///
170 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#preup)
171 #[builder(setter(into), default)]
172 pub pre_up: Vec<String>,
173
174 /// Commands, that will be executed before the interface is brought down
175 ///
176 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#predown)
177 #[builder(setter(into), default)]
178 pub pre_down: Vec<String>,
179
180 /// Commands, that will be executed after the interface is brought up
181 ///
182 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#postup)
183 #[builder(setter(into), default)]
184 pub post_up: Vec<String>,
185
186 /// Commands, that will be executed after the interface is brought down
187 ///
188 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#postdown)
189 #[builder(setter(into), default)]
190 pub post_down: Vec<String>,
191
192 /// Peers.
193 ///
194 /// Create them using [`PeerBuilder`] or [`Interface::to_peer`] method.
195 ///
196 /// [Wireguard docs](https://github.com/pirate/wireguard-docs#peer)
197 #[builder(setter(into), default)]
198 pub peers: Vec<Peer>,
199}
200
201impl Interface {
202 /// Get [`Peer`] from interface.
203 ///
204 /// # Examples
205 ///
206 /// ```
207 /// # use wireguard_conf::prelude::*;
208 /// // Create server node
209 /// let mut server = InterfaceBuilder::new()
210 /// // <snip>
211 /// .build();
212 ///
213 /// // Create client node, and add server to client's peers
214 /// let client = InterfaceBuilder::new()
215 /// // <snip>
216 /// .peers([server.to_peer()]) // convert `Interface` to `Peer` using `.to_peer()` method.
217 /// .build();
218 ///
219 /// // Add client to server's peers
220 /// server.peers.push(client.to_peer());
221 ///
222 /// println!("Server config:\n{server}");
223 /// println!("Client config:\n{client}");
224 /// ```
225 pub fn to_peer(&self) -> Peer {
226 Peer {
227 endpoint: self.endpoint.as_ref().map(|server_endpoint| {
228 format!(
229 "{server_endpoint}:{server_port}",
230 server_port = self.listen_port.unwrap_or(51820)
231 )
232 }),
233 allowed_ips: self.address.clone(),
234 key: Either::Left(self.private_key.clone()),
235 preshared_key: None,
236 persistent_keepalive: 0,
237 }
238 }
239}
240
241impl Interface {
242 /// Create new `InterfaceBuilder`. Alias for `InterfaceBuilder::new()`.
243 ///
244 /// ```rust
245 /// # use wireguard_conf::prelude::*;
246 /// # use wireguard_conf::as_ipnet;
247 /// #
248 /// let interface = Interface::builder()
249 /// .address([as_ipnet!("10.0.0.1/24")])
250 /// // <snip>
251 /// .build();
252 /// ```
253 #[must_use]
254 pub fn builder() -> InterfaceBuilder {
255 InterfaceBuilder::default()
256 }
257}
258
259impl InterfaceBuilder {
260 /// Create new `InterfaceBuilder`.
261 ///
262 /// ```rust
263 /// # use wireguard_conf::prelude::*;
264 /// # use wireguard_conf::as_ipnet;
265 /// #
266 /// let interface = InterfaceBuilder::new()
267 /// .address([as_ipnet!("10.0.0.1/24")])
268 /// // <snip>
269 /// .build();
270 /// ```
271 #[must_use]
272 pub fn new() -> Self {
273 Self::default()
274 }
275
276 /// Adds IP Network to `Address = ...` field.
277 ///
278 /// `value` is [`Into<IpNet>`], which means that it can be either [`ipnet::IpNet`] or [`std::net::IpAddr`].
279 ///
280 /// # Example
281 ///
282 /// ```rust
283 /// use wireguard_conf::{as_ipnet, prelude::*};
284 ///
285 /// let interface = InterfaceBuilder::new()
286 /// .add_network(as_ipnet!("1.2.3.4/16"))
287 /// .add_network(as_ipnet!("fd00:DEAD:BEEF::1/48"))
288 /// .build();
289 ///
290 /// assert_eq!(
291 /// interface.address,
292 /// vec![
293 /// as_ipnet!("1.2.3.4/16"),
294 /// as_ipnet!("fd00:DEAD:BEEF::1/48")
295 /// ]
296 /// );
297 /// ```
298 pub fn add_network<T: Into<IpNet>>(&mut self, value: T) -> &mut Self {
299 if self.address.is_none() {
300 self.address = Some(Vec::with_capacity(1));
301 }
302
303 self.address
304 .as_mut()
305 .unwrap_or_else(|| unreachable!())
306 .push(value.into());
307 self
308 }
309
310 /// Adds IP address to `Address = ...` field.
311 ///
312 /// `value` is [`Into<IpAddr>`], which means that it can be either [`std::net::Ipv4Addr`] or [`std::net::Ipv6Addr`].
313 ///
314 /// # Example
315 ///
316 /// ```rust
317 /// use wireguard_conf::{as_ipaddr, as_ipnet, prelude::*};
318 ///
319 /// let interface = InterfaceBuilder::new()
320 /// .add_address(as_ipaddr!("1.2.3.4"))
321 /// .add_address(as_ipaddr!("fd00::1"))
322 /// .build();
323 ///
324 /// // /32 and /128 are added automatically
325 /// assert_eq!(
326 /// interface.address,
327 /// vec![
328 /// as_ipnet!("1.2.3.4/32"),
329 /// as_ipnet!("fd00::1/128"),
330 /// ]
331 /// );
332 /// ```
333 pub fn add_address<T: Into<IpAddr>>(&mut self, value: T) -> &mut Self {
334 if self.address.is_none() {
335 self.address = Some(Vec::with_capacity(1));
336 }
337
338 let ip_addr = value.into();
339 let ip_net = if ip_addr.is_ipv4() {
340 IpNet::new_assert(ip_addr, 32) // 1.2.3.4/32
341 } else {
342 IpNet::new_assert(ip_addr, 128) // fd00::1/128
343 };
344
345 self.address
346 .as_mut()
347 .unwrap_or_else(|| unreachable!())
348 .push(ip_net);
349 self
350 }
351
352 /// Builds an `Interface`.
353 pub fn build(&self) -> Interface {
354 self.fallible_build().unwrap_or_else(|_| unreachable!())
355 }
356}
357
358impl fmt::Display for Interface {
359 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
360 writeln!(f, "[Interface]")?;
361 if let Some(endpoint) = &self.endpoint {
362 writeln!(f, "# Name = {endpoint}")?;
363 }
364 writeln!(
365 f,
366 "Address = {}",
367 self.address
368 .iter()
369 .map(ToString::to_string)
370 .map(|addr| {
371 if addr.ends_with("/32") {
372 addr.trim_end_matches("/32").to_owned()
373 } else if addr.ends_with("/128") {
374 addr.trim_end_matches("/128").to_owned()
375 } else {
376 addr
377 }
378 })
379 .join(",")
380 )?;
381 if let Some(listen_port) = self.listen_port {
382 writeln!(f, "ListenPort = {listen_port}")?;
383 }
384 writeln!(f, "PrivateKey = {}", self.private_key)?;
385 if !self.dns.is_empty() {
386 writeln!(f, "DNS = {}", self.dns.join(","))?;
387 }
388 if let Some(table) = &self.table {
389 writeln!(f, "Table = {table}")?;
390 }
391 if let Some(mtu) = &self.mtu {
392 writeln!(f, "MTU = {mtu}")?;
393 }
394
395 if !self.pre_up.is_empty() {
396 writeln!(f)?;
397 for snippet in &self.pre_up {
398 writeln!(f, "PreUp = {snippet}")?;
399 }
400 }
401 if !self.pre_down.is_empty() {
402 writeln!(f)?;
403 for snippet in &self.pre_down {
404 writeln!(f, "PreDown = {snippet}")?;
405 }
406 }
407 if !self.post_up.is_empty() {
408 writeln!(f)?;
409 for snippet in &self.post_up {
410 writeln!(f, "PostUp = {snippet}")?;
411 }
412 }
413 if !self.post_down.is_empty() {
414 writeln!(f)?;
415 for snippet in &self.post_down {
416 writeln!(f, "PostDown = {snippet}")?;
417 }
418 }
419
420 #[cfg(feature = "amneziawg")]
421 if let Some(amnezia_settings) = &self.amnezia_settings {
422 writeln!(f)?;
423 writeln!(f, "{amnezia_settings}")?;
424 }
425
426 for peer in &self.peers {
427 writeln!(f)?;
428 writeln!(f, "{peer}")?;
429 }
430
431 fmt::Result::Ok(())
432 }
433}