bgp: add otc attribute

- Introduce the Only To Customer (OTC) optional transitive attribute.
- Move RoleName to holo-utils/bgp.rs

Signed-off-by: Paul Wekesa <paul1tw1@gmail.com>

Author: Paul-weqe

holo-bgp/src/neighbor.rs

@@ -13,7 +13,7 @@ use std::time::Duration;
 use arbitrary::Arbitrary;
 use chrono::{DateTime, Utc};
 use holo_protocol::InstanceChannelsTx;
-use holo_utils::bgp::{AfiSafi, RouteType, WellKnownCommunities};
+use holo_utils::bgp::{AfiSafi, RoleName, RouteType, WellKnownCommunities};
 use holo_utils::ibus::IbusChannelsTx;
 use holo_utils::socket::{TTL_MAX, TcpConnInfo, TcpStream};
 use holo_utils::task::{IntervalTask, Task, TimeoutTask};
@@ -30,8 +30,7 @@ use crate::northbound::notification;
 use crate::northbound::rpc::ClearType;
 use crate::packet::attribute::Attrs;
 use crate::packet::consts::{
-    AS_TRANS, Afi, BGP_VERSION, CeaseSubcode, ErrorCode, FsmErrorSubcode,
-    RoleName, Safi,
+    AS_TRANS, Afi, BGP_VERSION, CeaseSubcode, ErrorCode, FsmErrorSubcode, Safi,
 };
 use crate::packet::message::{
     Capability, DecodeCxt, EncodeCxt, KeepaliveMsg, Message,

holo-bgp/src/northbound/configuration.rs

@@ -16,7 +16,7 @@ use holo_northbound::configuration::{
     Callbacks, CallbacksBuilder, Provider, ValidationCallbacks,
     ValidationCallbacksBuilder,
 };
-use holo_utils::bgp::AfiSafi;
+use holo_utils::bgp::{AfiSafi, RoleName};
 use holo_utils::ip::{AddressFamily, IpAddrKind};
 use holo_utils::policy::{ApplyPolicyCfg, DefaultPolicyType};
 use holo_utils::protocol::Protocol;
@@ -28,7 +28,7 @@ use crate::instance::{Instance, InstanceUpView};
 use crate::neighbor::{Neighbor, PeerType, fsm};
 use crate::network;
 use crate::northbound::yang_gen::bgp;
-use crate::packet::consts::{CeaseSubcode, ErrorCode, RoleName};
+use crate::packet::consts::{CeaseSubcode, ErrorCode};
 use crate::packet::message::{Message, NotificationMsg};
 use crate::rib::RouteOrigin;
 

holo-bgp/src/northbound/yang.rs

@@ -16,7 +16,7 @@ use crate::northbound::configuration::{
 use crate::packet::consts::{
     AddPathMode, AsPathSegmentType, CapabilityCode, CeaseSubcode, ErrorCode,
     FsmErrorSubcode, MessageHeaderErrorSubcode, OpenMessageErrorSubcode,
-    RoleName, RouteRefreshErrorSubcode, Safi, UpdateMessageErrorSubcode,
+    RouteRefreshErrorSubcode, Safi, UpdateMessageErrorSubcode,
 };
 use crate::packet::message::NotificationMsg;
 use crate::rib::{RouteIneligibleReason, RouteOrigin, RouteRejectReason};
@@ -335,19 +335,6 @@ impl ToYang for RouteRejectReason {
 
 // ===== TryFromYang implementations =====
 
-impl TryFromYang for RoleName {
-    fn try_from_yang(value: &str) -> Option<RoleName> {
-        match value {
-            "provider" => Some(RoleName::Provider),
-            "customer" => Some(RoleName::Customer),
-            "peer" => Some(RoleName::Peer),
-            "rs-client" => Some(RoleName::RsClient),
-            "rs" => Some(RoleName::Rs),
-            _ => None,
-        }
-    }
-}
-
 impl TryFromYang for PrivateAsRemove {
     fn try_from_yang(value: &str) -> Option<PrivateAsRemove> {
         match value {

holo-bgp/src/packet/attribute.rs

@@ -58,6 +58,7 @@ pub struct BaseAttrs {
     pub atomic_aggregate: Option<()>,
     pub originator_id: Option<Ipv4Addr>,
     pub cluster_list: Option<ClusterList>,
+    pub otc: Option<u32>,
 }
 
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -181,6 +182,11 @@ impl Attrs {
             atomic_aggregate::encode(buf);
         }
 
+        // Only To Customer (OTC) attribute.
+        if let Some(otc) = self.base.otc {
+            otc::encode(otc, buf);
+        }
+
         // AGGREGATOR attribute.
         if let Some(aggregator) = &self.base.aggregator {
             aggregator.encode(
@@ -278,6 +284,7 @@ impl Attrs {
         let mut ext_comm = None;
         let mut extv6_comm = None;
         let mut large_comm = None;
+        let mut otc = None;
         let mut unknown = vec![];
         let mut withdraw = false;
 
@@ -452,6 +459,7 @@ impl Attrs {
                 AttrType::LargeCommunity => {
                     LargeComms::decode(&mut buf, &mut large_comm)
                 }
+                AttrType::Otc => otc::decode(&mut buf, &mut otc),
             } {
                 // Log malformed attribute.
                 Debug::NbrAttrError(attr_type, error).log();
@@ -493,6 +501,7 @@ impl Attrs {
                     atomic_aggregate,
                     originator_id,
                     cluster_list,
+                    otc,
                 },
                 comm,
                 ext_comm,
@@ -549,6 +558,9 @@ impl Attrs {
         if let Some(large_comm) = &self.large_comm {
             length += large_comm.length();
         }
+        if self.base.otc.is_some() {
+            length += otc::length();
+        }
 
         length
     }
@@ -865,6 +877,37 @@ mod med {
     }
 }
 
+// ==== Only To Customer(OTC) attribute ====
+
+mod otc {
+    use super::*;
+    const LEN: u8 = 4;
+
+    pub(super) fn encode(otc: u32, buf: &mut BytesMut) {
+        buf.put_u8(AttrFlags::OPTIONAL.bits());
+        buf.put_u8(AttrType::Otc as u8);
+        buf.put_u8(LEN);
+        buf.put_u32(otc);
+    }
+
+    pub(super) fn decode(
+        buf: &mut Bytes,
+        otc: &mut Option<u32>,
+    ) -> Result<(), AttrError> {
+        if buf.remaining() != LEN as usize {
+            return Err(AttrError::Withdraw);
+        }
+
+        let value = buf.try_get_u32()?;
+        *otc = Some(value);
+        Ok(())
+    }
+
+    pub(super) fn length() -> u16 {
+        ATTR_MIN_LEN + LEN as u16
+    }
+}
+
 // ===== LOCAL_PREF attribute =====
 
 mod local_pref {
@@ -1450,9 +1493,8 @@ fn attribute_flags(attr_type: AttrType) -> AttrFlags {
         | AttrType::As4Path
         | AttrType::As4Aggregator
         | AttrType::Extv6Community
-        | AttrType::LargeCommunity => {
-            AttrFlags::TRANSITIVE | AttrFlags::OPTIONAL
-        }
+        | AttrType::LargeCommunity
+        | AttrType::Otc => AttrFlags::TRANSITIVE | AttrFlags::OPTIONAL,
     }
 }
 

holo-bgp/src/packet/consts.rs

@@ -4,8 +4,6 @@
 // SPDX-License-Identifier: MIT
 //
 
-use std::collections::HashMap;
-
 use arbitrary::Arbitrary;
 use bitflags::bitflags;
 use holo_utils::ip::AddressFamily;
@@ -318,46 +316,6 @@ pub enum AttrType {
     //AttrSet = 128,
 }
 
-// Roles as defined in RFC 9234.
-#[derive(Clone, Copy, Ord, Debug, Eq, Hash, PartialEq, PartialOrd)]
-#[derive(FromPrimitive, ToPrimitive)]
-#[derive(Deserialize, Serialize)]
-pub enum RoleName {
-    Provider = 0,
-    Rs = 1,
-    RsClient = 2,
-    Customer = 3,
-    Peer = 4, // i.e Lateral Peer.
-}
-
-impl RoleName {
-    fn allowed_role() -> HashMap<Self, Self> {
-        HashMap::from([
-            (RoleName::Provider, RoleName::Customer),
-            (RoleName::Customer, RoleName::Provider),
-            (RoleName::Rs, RoleName::RsClient),
-            (RoleName::RsClient, RoleName::Rs),
-            (RoleName::Peer, RoleName::Peer),
-        ])
-    }
-
-    // Maps the Local AS Role and the Remote AS Role.
-    // If the Roles do not match, there will be a NotificationMsg that will be
-    // sent back.
-    // RFC 9234 section 4.2 Table 2.
-    pub fn validate_role_correctness(
-        local_role: &RoleName,
-        remote_role: &RoleName,
-    ) -> bool {
-        if let Some(approved_role) = Self::allowed_role().get(local_role)
-            && approved_role == remote_role
-        {
-            return true;
-        }
-        false
-    }
-}
-
 // BGP Origin.
 pub type Origin = holo_utils::bgp::Origin;
 

holo-bgp/src/packet/message.rs

@@ -10,6 +10,7 @@ use std::net::{Ipv4Addr, Ipv6Addr};
 use arbitrary::Arbitrary;
 use bytes::{Buf, BufMut, Bytes, BytesMut};
 use enum_as_inner::EnumAsInner;
+use holo_utils::bgp::RoleName;
 use holo_utils::bytes::{BytesExt, BytesMutExt, TLS_BUF};
 use holo_utils::ip::{
     Ipv4AddrExt, Ipv4NetworkExt, Ipv6AddrExt, Ipv6NetworkExt,
@@ -24,7 +25,7 @@ use crate::packet::attribute::Attrs;
 use crate::packet::consts::{
     AddPathMode, Afi, BGP_VERSION, CapabilityCode, ErrorCode,
     MessageHeaderErrorSubcode, MessageType, OpenMessageErrorSubcode,
-    OpenParamType, RoleName, Safi, UpdateMessageErrorSubcode,
+    OpenParamType, Safi, UpdateMessageErrorSubcode,
 };
 use crate::packet::error::{
     DecodeError, MessageHeaderError, OpenMessageError, UpdateMessageError,

holo-utils/src/bgp.rs

@@ -12,6 +12,7 @@
 //! eliminating the need for shared definitions.
 
 use std::borrow::Cow;
+use std::collections::HashMap;
 use std::net::Ipv6Addr;
 
 use holo_yang::{ToYang, TryFromYang};
@@ -77,6 +78,18 @@ pub enum WellKnownCommunities {
     NoExportSubconfed = 0xFFFFFF03,
 }
 
+// Roles as defined in RFC 9234.
+#[derive(Clone, Copy, Ord, Debug, Eq, Hash, PartialEq, PartialOrd)]
+#[derive(FromPrimitive, ToPrimitive)]
+#[derive(Deserialize, Serialize)]
+pub enum RoleName {
+    Provider = 0,
+    Rs = 1,
+    RsClient = 2,
+    Customer = 3,
+    Peer = 4, // i.e Lateral Peer.
+}
+
 // ===== impl AfiSafi =====
 
 impl ToYang for AfiSafi {
@@ -268,3 +281,58 @@ impl TryFromYang for LargeComm {
         None
     }
 }
+
+// ==== impl RoleName ====
+
+impl RoleName {
+    fn allowed_role() -> HashMap<Self, Self> {
+        HashMap::from([
+            (RoleName::Provider, RoleName::Customer),
+            (RoleName::Customer, RoleName::Provider),
+            (RoleName::Rs, RoleName::RsClient),
+            (RoleName::RsClient, RoleName::Rs),
+            (RoleName::Peer, RoleName::Peer),
+        ])
+    }
+
+    // Maps the Local AS Role and the Remote AS Role.
+    // If the Roles do not match, there will be a NotificationMsg that will be
+    // sent back.
+    // RFC 9234 section 4.2 Table 2.
+    pub fn validate_role_correctness(
+        local_role: &RoleName,
+        remote_role: &RoleName,
+    ) -> bool {
+        if let Some(approved_role) = Self::allowed_role().get(local_role)
+            && approved_role == remote_role
+        {
+            return true;
+        }
+        false
+    }
+}
+
+impl TryFromYang for RoleName {
+    fn try_from_yang(value: &str) -> Option<RoleName> {
+        match value {
+            "provider" => Some(RoleName::Provider),
+            "customer" => Some(RoleName::Customer),
+            "peer" => Some(RoleName::Peer),
+            "rs-client" => Some(RoleName::RsClient),
+            "rs" => Some(RoleName::Rs),
+            _ => None,
+        }
+    }
+}
+
+impl ToYang for RoleName {
+    fn to_yang(&self) -> Cow<'static, str> {
+        match self {
+            RoleName::Provider => "provider".into(),
+            RoleName::Customer => "customer".into(),
+            RoleName::Peer => "peer".into(),
+            RoleName::RsClient => "rs-client".into(),
+            RoleName::Rs => "rs".into(),
+        }
+    }
+}