Skip to main content

bgpkit_parser/models/network/
afi.rs

1use num_enum::{IntoPrimitive, TryFromPrimitive};
2use std::net::IpAddr;
3
4/// AFI -- Address Family Identifier
5///
6/// <https://www.iana.org/assignments/address-family-numbers/address-family-numbers.xhtml>
7#[derive(Debug, PartialEq, TryFromPrimitive, IntoPrimitive, Clone, Copy, Eq, Hash)]
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS), ts(export))]
10#[repr(u16)]
11pub enum Afi {
12    Ipv4 = 1,
13    Ipv6 = 2,
14    /// Layer 2 VPN address family, used to carry EVPN - RFC 7432
15    L2vpn = 25,
16    /// BGP Link-State - RFC 7752
17    LinkState = 16388,
18}
19
20impl From<IpAddr> for Afi {
21    #[inline]
22    fn from(value: IpAddr) -> Self {
23        match value {
24            IpAddr::V4(_) => Afi::Ipv4,
25            IpAddr::V6(_) => Afi::Ipv6,
26        }
27    }
28}
29
30/// SAFI -- Subsequent Address Family Identifier
31///
32/// SAFI can be: Unicast, Multicast, or both, as well as MPLS VPN variants.
33/// The AFI determines the IP version (IPv4/IPv6), while SAFI determines the application.
34///
35/// References:
36/// - RFC 4760: Multiprotocol Extensions for BGP-4
37/// - RFC 4364: BGP/MPLS IP Virtual Private Networks (VPNs) - defines SAFI 128
38/// - RFC 6514: BGP Signaling of Multicast VPNs - defines SAFI 129
39/// - RFC 7752: BGP Link-State - defines SAFI 71, 72
40/// - RFC 8950: Advertising IPv4 Network Layer Reachability Information (NLRI) with an IPv6 Next Hop
41#[derive(Debug, PartialEq, TryFromPrimitive, IntoPrimitive, Clone, Copy, Eq, Hash)]
42#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
43#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS), ts(export))]
44#[repr(u8)]
45pub enum Safi {
46    Unicast = 1,
47    Multicast = 2,
48    UnicastMulticast = 3,
49    /// MPLS-labeled address - RFC 3107/8277
50    /// SAFI 4 for labeled unicast prefixes (not VPN)
51    MplsLabel = 4,
52    /// BGP EVPN - RFC 7432
53    Evpn = 70,
54    /// BGP Link-State - RFC 7752
55    LinkState = 71,
56    /// BGP Link-State VPN - RFC 7752
57    LinkStateVpn = 72,
58    /// MPLS-labeled VPN address - RFC 4364, used in RFC 8950 Section 4
59    /// Works with both AFI 1 (VPN-IPv4) and AFI 2 (VPN-IPv6)
60    MplsVpn = 128,
61    /// Multicast for BGP/MPLS IP VPNs - RFC 6514
62    /// Works with both AFI 1 (Multicast VPN-IPv4) and AFI 2 (Multicast VPN-IPv6)
63    MulticastVpn = 129,
64    /// Flow Specification - RFC 8955/8956
65    /// Works with both AFI 1 (IPv4 Flow-Spec) and AFI 2 (IPv6 Flow-Spec)
66    FlowSpec = 133,
67    /// L3VPN Flow Specification - RFC 8955/8956
68    /// Works with both AFI 1 (VPN-IPv4 Flow-Spec) and AFI 2 (VPN-IPv6 Flow-Spec)
69    FlowSpecL3Vpn = 134,
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75
76    #[test]
77    fn test_afi_from() {
78        assert_eq!(
79            Afi::from(IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1))),
80            Afi::Ipv4
81        );
82        assert_eq!(
83            Afi::from(IpAddr::V6(std::net::Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1))),
84            Afi::Ipv6
85        );
86    }
87
88    #[test]
89    fn test_afi_safi_repr() {
90        assert_eq!(Afi::Ipv4 as u16, 1);
91        assert_eq!(Afi::Ipv6 as u16, 2);
92        assert_eq!(Afi::L2vpn as u16, 25);
93        assert_eq!(Afi::LinkState as u16, 16388);
94
95        assert_eq!(Safi::Unicast as u8, 1);
96        assert_eq!(Safi::Multicast as u8, 2);
97        assert_eq!(Safi::UnicastMulticast as u8, 3);
98        // RFC 7432 EVPN SAFI value
99        assert_eq!(Safi::Evpn as u8, 70);
100        // RFC 7752 Link-State SAFI values
101        assert_eq!(Safi::LinkState as u8, 71);
102        assert_eq!(Safi::LinkStateVpn as u8, 72);
103        // RFC 8950 VPN SAFI values
104        assert_eq!(Safi::MplsVpn as u8, 128);
105        assert_eq!(Safi::MulticastVpn as u8, 129);
106        // RFC 8955/8956 Flow-Spec SAFI values
107        assert_eq!(Safi::FlowSpec as u8, 133);
108        assert_eq!(Safi::FlowSpecL3Vpn as u8, 134);
109    }
110
111    #[test]
112    #[cfg(feature = "serde")]
113    fn test_afi_safi_serde() {
114        let afi = Afi::Ipv4;
115        let serialized = serde_json::to_string(&afi).unwrap();
116        assert_eq!(serialized, "\"Ipv4\"");
117        let deserialized: Afi = serde_json::from_str(&serialized).unwrap();
118        assert_eq!(deserialized, afi);
119
120        let afi = Afi::Ipv6;
121        let serialized = serde_json::to_string(&afi).unwrap();
122        assert_eq!(serialized, "\"Ipv6\"");
123        let deserialized: Afi = serde_json::from_str(&serialized).unwrap();
124        assert_eq!(deserialized, afi);
125
126        let safi = Safi::Unicast;
127        let serialized = serde_json::to_string(&safi).unwrap();
128        assert_eq!(serialized, "\"Unicast\"");
129        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
130        assert_eq!(deserialized, safi);
131
132        let safi = Safi::Multicast;
133        let serialized = serde_json::to_string(&safi).unwrap();
134        assert_eq!(serialized, "\"Multicast\"");
135        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
136        assert_eq!(deserialized, safi);
137
138        let safi = Safi::UnicastMulticast;
139        let serialized = serde_json::to_string(&safi).unwrap();
140        assert_eq!(serialized, "\"UnicastMulticast\"");
141        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
142        assert_eq!(deserialized, safi);
143
144        // RFC 8950 VPN SAFI variants
145        let safi = Safi::MplsVpn;
146        let serialized = serde_json::to_string(&safi).unwrap();
147        assert_eq!(serialized, "\"MplsVpn\"");
148        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
149        assert_eq!(deserialized, safi);
150
151        let safi = Safi::MulticastVpn;
152        let serialized = serde_json::to_string(&safi).unwrap();
153        assert_eq!(serialized, "\"MulticastVpn\"");
154        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
155        assert_eq!(deserialized, safi);
156
157        // RFC 8955/8956 Flow-Spec SAFI variants
158        let safi = Safi::FlowSpec;
159        let serialized = serde_json::to_string(&safi).unwrap();
160        assert_eq!(serialized, "\"FlowSpec\"");
161        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
162        assert_eq!(deserialized, safi);
163
164        let safi = Safi::FlowSpecL3Vpn;
165        let serialized = serde_json::to_string(&safi).unwrap();
166        assert_eq!(serialized, "\"FlowSpecL3Vpn\"");
167        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
168        assert_eq!(deserialized, safi);
169    }
170}