From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from firstgate.proxmox.com (firstgate.proxmox.com [IPv6:2a01:7e0:0:424::9]) by lore.proxmox.com (Postfix) with ESMTPS id 957571FF165 for ; Thu, 22 May 2025 18:18:02 +0200 (CEST) Received: from firstgate.proxmox.com (localhost [127.0.0.1]) by firstgate.proxmox.com (Proxmox) with ESMTP id 3D6AB9E3A; Thu, 22 May 2025 18:17:41 +0200 (CEST) From: Stefan Hanreich To: pve-devel@lists.proxmox.com Date: Thu, 22 May 2025 18:16:26 +0200 Message-Id: <20250522161731.537011-11-s.hanreich@proxmox.com> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250522161731.537011-1-s.hanreich@proxmox.com> References: <20250522161731.537011-1-s.hanreich@proxmox.com> MIME-Version: 1.0 X-SPAM-LEVEL: Spam detection results: 0 AWL -0.231 Adjusted score from AWL reputation of From: address BAYES_00 -1.9 Bayes spam probability is 0 to 1% DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment KAM_LAZY_DOMAIN_SECURITY 1 Sending domain does not have any anti-forgery methods RDNS_NONE 0.793 Delivered to internal network by a host with no rDNS SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_NONE 0.001 SPF: sender does not publish an SPF Record Subject: [pve-devel] [PATCH proxmox-ve-rs v3 05/21] frr: add common frr types X-BeenThere: pve-devel@lists.proxmox.com X-Mailman-Version: 2.1.29 Precedence: list List-Id: Proxmox VE development discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Proxmox VE development discussion Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: pve-devel-bounces@lists.proxmox.com Sender: "pve-devel" From: Gabriel Goller Add common FRR configuration types such as FrrWord, CommonInterfaceName, etc. These are some common types that are used by both openfabric and ospf and the generic types that span the two protocols. The FrrWord is a simple primitive in FRR, which is a ascii-string that doesn't contain whitespaces. Signed-off-by: Gabriel Goller --- proxmox-frr/src/lib.rs | 118 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) diff --git a/proxmox-frr/src/lib.rs b/proxmox-frr/src/lib.rs index e69de29..5e0b346 100644 --- a/proxmox-frr/src/lib.rs +++ b/proxmox-frr/src/lib.rs @@ -0,0 +1,118 @@ +use std::{fmt::Display, str::FromStr}; + +use serde::{Deserialize, Serialize}; +use serde_with::{DeserializeFromStr, SerializeDisplay}; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum RouterNameError { + #[error("invalid name")] + InvalidName, + #[error("invalid frr word")] + FrrWordError(#[from] FrrWordError), +} + +/// The interface name is the same on ospf and openfabric, but it is an enum so we can have two +/// different entries in the hashmap. This allows us to have an interface in an ospf and openfabric +/// fabric. +#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Hash, PartialOrd, Ord)] +pub enum InterfaceName { + Openfabric(CommonInterfaceName), + Ospf(CommonInterfaceName), +} + +impl Display for InterfaceName { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + InterfaceName::Openfabric(frr_word) => frr_word.fmt(f), + InterfaceName::Ospf(frr_word) => frr_word.fmt(f), + } + } +} + +#[derive(Error, Debug)] +pub enum FrrWordError { + #[error("word is empty")] + IsEmpty, + #[error("word contains invalid character")] + InvalidCharacter, +} + +/// A simple FRR Word. +/// +/// Every string argument or value in FRR is an FrrWord. FrrWords must only contain ascii +/// characters and must not have a whitespace. +#[derive( + Clone, Debug, PartialEq, Eq, Hash, DeserializeFromStr, SerializeDisplay, PartialOrd, Ord, +)] +pub struct FrrWord(String); + +impl FrrWord { + pub fn new(name: String) -> Result { + if name.is_empty() { + return Err(FrrWordError::IsEmpty); + } + + if name + .as_bytes() + .iter() + .any(|c| !c.is_ascii() || c.is_ascii_whitespace()) + { + eprintln!("invalid char in: \"{name}\""); + return Err(FrrWordError::InvalidCharacter); + } + + Ok(Self(name)) + } +} + +impl FromStr for FrrWord { + type Err = FrrWordError; + + fn from_str(s: &str) -> Result { + FrrWord::new(s.to_string()) + } +} + +impl Display for FrrWord { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.0.fmt(f) + } +} + +impl AsRef for FrrWord { + fn as_ref(&self) -> &str { + &self.0 + } +} + +#[derive(Error, Debug)] +pub enum CommonInterfaceNameError { + #[error("interface name too long")] + TooLong, +} + +/// Name of a interface, which is common between all protocols. +/// +/// FRR itself doesn't enforce any limits, but the kernel does. Linux only allows interface names +/// to be a maximum of 16 bytes. This is enforced by this struct. +#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Hash, PartialOrd, Ord)] +pub struct CommonInterfaceName(String); + +impl FromStr for CommonInterfaceName { + type Err = CommonInterfaceNameError; + + fn from_str(s: &str) -> Result { + if s.len() <= 15 { + Ok(Self(s.to_owned())) + } else { + Err(CommonInterfaceNameError::TooLong) + } + } +} + +impl Display for CommonInterfaceName { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.0.fmt(f) + } +} -- 2.39.5 _______________________________________________ pve-devel mailing list pve-devel@lists.proxmox.com https://lists.proxmox.com/cgi-bin/mailman/listinfo/pve-devel