[pve-devel] [PATCH proxmox-ve-rs 08/17] frr: add ospf types

[Gabriel Goller]

Add OSPF-specific FRR types. This also reuses the types from
proxmox-network-types.

The NetworkType FRR option is implemented here, but not exposed to the
interface, as we want to keep it simple. So the UI has a simple
"unnumbered" check and we set the NetworkType to "Point-to-Point". The
other options are also not that interesting.

Signed-off-by: Gabriel Goller <g.goller at proxmox.com>
---
 proxmox-frr/src/lib.rs  |  20 ++++++
 proxmox-frr/src/ospf.rs | 135 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 155 insertions(+)
 create mode 100644 proxmox-frr/src/ospf.rs

diff --git a/proxmox-frr/src/lib.rs b/proxmox-frr/src/lib.rs
index d54f83127501..1160a71b3d9c 100644
--- a/proxmox-frr/src/lib.rs
+++ b/proxmox-frr/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod openfabric;
+pub mod ospf;
 use std::{collections::BTreeMap, fmt::Display, str::FromStr};
 
 use serde::{Deserialize, Serialize};
@@ -31,6 +32,25 @@ impl Display for InterfaceName {
     }
 }
 
+/// Generic FRR Interface.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, PartialOrd, Ord)]
+pub enum Interface {
+    OpenFabric(openfabric::OpenFabricInterface),
+    Ospf(ospf::OspfInterface),
+}
+
+impl From<openfabric::OpenFabricInterface> for Interface {
+    fn from(value: openfabric::OpenFabricInterface) -> Self {
+        Self::OpenFabric(value)
+    }
+}
+
+impl From<ospf::OspfInterface> for Interface {
+    fn from(value: ospf::OspfInterface) -> Self {
+        Self::Ospf(value)
+    }
+}
+
 #[derive(Error, Debug)]
 pub enum FrrWordError {
     #[error("word is empty")]
diff --git a/proxmox-frr/src/ospf.rs b/proxmox-frr/src/ospf.rs
new file mode 100644
index 000000000000..f41b1c0d400a
--- /dev/null
+++ b/proxmox-frr/src/ospf.rs
@@ -0,0 +1,135 @@
+use std::fmt::Debug;
+use std::fmt::Display;
+use std::net::Ipv4Addr;
+
+use serde::{Deserialize, Serialize};
+
+use thiserror::Error;
+
+use crate::{FrrWord, FrrWordError};
+
+/// The name of the ospf frr router. There is only one ospf fabric possible in frr (ignoring
+/// multiple invocations of the ospfd daemon) and the separation is done with areas. Still,
+/// different areas have the same frr router, so the name of the router is just "ospf" in "router
+/// ospf". This type still contains the Area so that we can insert it in the Hashmap.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
+pub struct OspfRouterName(Area);
+
+impl From<Area> for OspfRouterName {
+    fn from(value: Area) -> Self {
+        Self(value)
+    }
+}
+
+impl Display for OspfRouterName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ospf")
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum AreaParsingError {
+    #[error("Invalid area idenitifier. Area must be a number or an ipv4 address.")]
+    InvalidArea,
+    #[error("Invalid area idenitifier. Missing 'area' prefix.")]
+    MissingPrefix,
+    #[error("Error parsing to FrrWord")]
+    FrrWordError(#[from] FrrWordError),
+}
+
+/// The OSPF Area. Most commonly, this is just a number, e.g. 5, but sometimes also a
+/// pseudo-ipaddress, e.g. 0.0.0.0
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
+pub struct Area(FrrWord);
+
+impl TryFrom<FrrWord> for Area {
+    type Error = AreaParsingError;
+
+    fn try_from(value: FrrWord) -> Result<Self, Self::Error> {
+        Area::new(value)
+    }
+}
+
+impl Area {
+    pub fn new(name: FrrWord) -> Result<Self, AreaParsingError> {
+        if name.as_ref().parse::<u32>().is_ok() || name.as_ref().parse::<Ipv4Addr>().is_ok() {
+            Ok(Self(name))
+        } else {
+            Err(AreaParsingError::InvalidArea)
+        }
+    }
+}
+
+impl Display for Area {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "area {}", self.0)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
+pub struct OspfRouter {
+    pub router_id: Ipv4Addr,
+}
+
+impl OspfRouter {
+    pub fn new(router_id: Ipv4Addr) -> Self {
+        Self { router_id }
+    }
+
+    pub fn router_id(&self) -> &Ipv4Addr {
+        &self.router_id
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum OspfInterfaceError {
+    #[error("Error parsing area")]
+    AreaParsingError(#[from] AreaParsingError),
+    #[error("Error parsing frr word")]
+    FrrWordParse(#[from] FrrWordError),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
+pub enum NetworkType {
+    Broadcast,
+    NonBroadcast,
+    /// If the interface is unnumbered (i.e. no specific ip-address at the interface, but the
+    /// router-id).
+    ///
+    /// If OSPF is used in an unnumbered way, you don't need to configure peer-to-peer (e.g. /31)
+    /// addresses at every interface, but you just need to set the router-id at the interface. You
+    /// also need to configure the `ip ospf network point-to-point` FRR option.
+    PointToPoint,
+    PointToMultipoint,
+}
+
+impl Display for NetworkType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            NetworkType::Broadcast => write!(f, "broadcast"),
+            NetworkType::NonBroadcast => write!(f, "non-broadcast"),
+            NetworkType::PointToPoint => write!(f, "point-to-point"),
+            NetworkType::PointToMultipoint => write!(f, "point-to-multicast"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
+pub struct OspfInterface {
+    // Note: an interface can only be a part of a single area(so no vec needed here)
+    pub area: Area,
+    pub passive: Option<bool>,
+    pub network_type: Option<NetworkType>,
+}
+
+impl OspfInterface {
+    pub fn area(&self) -> &Area {
+        &self.area
+    }
+    pub fn passive(&self) -> &Option<bool> {
+        &self.passive
+    }
+    pub fn network_type(&self) -> &Option<NetworkType> {
+        &self.network_type
+    }
+}
-- 
2.39.5