0
0
use std::collections::BTreeSet;
use std::net::IpAddr;
use ipnet::IpNet;
use rtnetlink::{Handle, LinkUnspec, RouteMessageBuilder};
use crate::routes::RouteTable;
pub fn tun_address(cidr: &IpNet) -> IpNet {
let host = cidr.network();
let max = match host {
IpAddr::V4(_) => 32,
IpAddr::V6(_) => 128,
};
IpNet::new(host, max).unwrap_or(*cidr)
}
pub fn preferred_source(table: &RouteTable, route: &IpNet) -> Option<IpAddr> {
table
.own_cidrs
.iter()
.find(|own| own.network().is_ipv4() == route.network().is_ipv4())
.map(|own| own.network())
}
#[derive(Debug, Default, PartialEq, Eq)]
pub struct RoutePlan {
pub add: Vec<IpNet>,
pub remove: Vec<IpNet>,
}
pub fn plan_routes(installed: &BTreeSet<IpNet>, desired: &BTreeSet<IpNet>) -> RoutePlan {
RoutePlan {
add: desired.difference(installed).copied().collect(),
remove: installed.difference(desired).copied().collect(),
}
}
pub struct NetConf {
handle: Handle,
index: u32,
addresses: BTreeSet<IpNet>,
routes: BTreeSet<IpNet>,
}
impl NetConf {
pub fn connect(index: u32) -> std::io::Result<NetConf> {
let (connection, handle, _) = rtnetlink::new_connection()?;
tokio::spawn(connection);
Ok(NetConf {
handle,
index,
addresses: BTreeSet::new(),
routes: BTreeSet::new(),
})
}
pub async fn bring_up(&self, mtu: u32) -> Result<(), rtnetlink::Error> {
self.handle
.link()
.set(LinkUnspec::new_with_index(self.index).mtu(mtu).up().build())
.execute()
.await
}
pub fn installed_routes(&self) -> &BTreeSet<IpNet> {
&self.routes
}
pub async fn sync(&mut self, table: &RouteTable) -> Vec<String> {
let mut failures = Vec::new();
let addresses_before = self.addresses.len();
for cidr in &table.own_cidrs {
let address = tun_address(cidr);
if self.addresses.contains(&address) {
continue;
}
let result = self
.handle
.address()
.add(self.index, address.addr(), address.prefix_len())
.replace()
.execute()
.await;
match result {
Ok(()) => {
self.addresses.insert(address);
}
Err(err) => failures.push(format!("address {address}: {err}")),
}
}
let desired = table.route_cidrs();
let mut plan = plan_routes(&self.routes, &desired);
if self.addresses.len() != addresses_before {
plan.add = desired.iter().copied().collect();
}
for cidr in plan.remove {
let message = match self.route_message(&cidr, None) {
Ok(message) => message,
Err(err) => {
failures.push(format!("route {cidr}: {err}"));
continue;
}
};
match self.handle.route().del(message).execute().await {
Ok(()) => {
self.routes.remove(&cidr);
}
Err(err) => {
self.routes.remove(&cidr);
failures.push(format!("delete route {cidr}: {err}"));
}
}
}
for cidr in plan.add {
let source = preferred_source(table, &cidr)
.filter(|source| self.addresses.contains(&tun_address(&IpNet::from(*source))));
let message = match self.route_message(&cidr, source) {
Ok(message) => message,
Err(err) => {
failures.push(format!("route {cidr}: {err}"));
continue;
}
};
match self.handle.route().add(message).replace().execute().await {
Ok(()) => {
self.routes.insert(cidr);
}
Err(err) => failures.push(format!("add route {cidr}: {err}")),
}
}
failures
}
fn route_message(
&self,
cidr: &IpNet,
source: Option<IpAddr>,
) -> Result<rtnetlink::packet_route::route::RouteMessage, String> {
let mut builder = RouteMessageBuilder::<IpAddr>::new()
.destination_prefix(cidr.network(), cidr.prefix_len())
.map_err(|err| err.to_string())?
.output_interface(self.index);
if let Some(source) = source {
builder = builder.pref_source(source).map_err(|err| err.to_string())?;
}
Ok(builder.build())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn net(text: &str) -> IpNet {
text.parse().unwrap()
}
#[test]
fn the_tun_takes_the_network_address_of_each_own_pod_cidr_as_a_host_address() {
assert_eq!(tun_address(&net("10.42.1.0/24")), net("10.42.1.0/32"));
assert_eq!(tun_address(&net("fd00:42:1::/64")), net("fd00:42:1::/128"));
}
#[test]
fn a_route_sync_adds_what_is_new_and_removes_what_is_gone() {
let installed = BTreeSet::from([net("10.42.2.0/24"), net("10.42.3.0/24")]);
let desired = BTreeSet::from([net("10.42.3.0/24"), net("10.42.4.0/24")]);
assert_eq!(
plan_routes(&installed, &desired),
RoutePlan {
add: vec![net("10.42.4.0/24")],
remove: vec![net("10.42.2.0/24")],
}
);
assert_eq!(plan_routes(&desired, &desired), RoutePlan::default());
}
}