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.gol...@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
_______________________________________________
pve-devel mailing list
pve-devel@lists.proxmox.com
https://lists.proxmox.com/cgi-bin/mailman/listinfo/pve-devel
