Skip to main content

bgpkit_parser/models/bgp/attributes/
nlri.rs

1use crate::models::*;
2use ipnet::IpNet;
3use std::fmt::Debug;
4use std::net::IpAddr;
5
6/// Network Layer Reachability Information
7#[derive(Debug, PartialEq, Clone, Eq)]
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS), ts(export))]
10pub struct Nlri {
11    pub afi: Afi,
12    pub safi: Safi,
13    pub next_hop: Option<NextHopAddress>,
14    /// Traditional IP prefixes for unicast/multicast
15    /// Also used for SAFI 4 withdrawals (RFC 8277 withdrawals carry no label semantics)
16    /// [`NetworkPrefix`] has a manual serde impl (string or `{prefix, path_id}`).
17    #[cfg_attr(
18        feature = "ts-rs",
19        ts(type = "(string | { prefix: string; path_id: number })[]")
20    )]
21    pub prefixes: Vec<NetworkPrefix>,
22    /// MPLS-labeled IP prefixes (SAFI 4 announcements only) - RFC 3107/8277
23    /// Withdrawals are routed to `prefixes`, not here
24    #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
25    pub labeled_prefixes: Option<Vec<LabeledNetworkPrefix>>,
26    /// Link-State NLRI data - RFC 7752
27    #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
28    pub link_state_nlris: Option<Vec<crate::models::bgp::linkstate::LinkStateNlri>>,
29    /// Flow-Spec NLRI data - RFC 8955/8956
30    #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
31    pub flowspec_nlris: Option<Vec<crate::models::bgp::flowspec::FlowSpecNlri>>,
32    /// EVPN NLRI data - RFC 7432 (AFI 25, SAFI 70)
33    #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
34    pub evpn_nlris: Option<Vec<crate::models::bgp::evpn::EvpnNlri>>,
35}
36
37impl Nlri {
38    /// Returns true if this NLRI refers to the IPv4 address space.
39    pub const fn is_ipv4(&self) -> bool {
40        matches!(self.afi, Afi::Ipv4)
41    }
42
43    /// Returns true if this NLRI refers to the IPv6 address space.
44    pub const fn is_ipv6(&self) -> bool {
45        matches!(self.afi, Afi::Ipv6)
46    }
47
48    /// Returns true if this NLRI refers to Link-State information.
49    pub const fn is_link_state(&self) -> bool {
50        matches!(self.afi, Afi::LinkState)
51    }
52
53    /// Returns true if this NLRI refers to Flow-Spec information.
54    pub const fn is_flowspec(&self) -> bool {
55        matches!(self.safi, Safi::FlowSpec | Safi::FlowSpecL3Vpn)
56    }
57
58    /// Returns true if this NLRI refers to EVPN (AFI 25, SAFI 70).
59    pub const fn is_evpn(&self) -> bool {
60        matches!(self.afi, Afi::L2vpn) && matches!(self.safi, Safi::Evpn)
61    }
62
63    /// Returns true if this NLRI refers to MPLS-labeled prefixes (SAFI 4).
64    pub const fn is_mpls_labeled(&self) -> bool {
65        matches!(self.safi, Safi::MplsLabel)
66    }
67
68    /// Returns true when this NLRI carries no reachability information in any
69    /// family, which is the shape of an MP_UNREACH end-of-RIB marker.
70    pub fn is_empty(&self) -> bool {
71        self.prefixes.is_empty()
72            && self.labeled_prefixes.as_ref().is_none_or(|p| p.is_empty())
73            && self.link_state_nlris.as_ref().is_none_or(|n| n.is_empty())
74            && self.flowspec_nlris.as_ref().is_none_or(|n| n.is_empty())
75            && self.evpn_nlris.as_ref().is_none_or(|n| n.is_empty())
76    }
77
78    /// Returns true if this NLRI refers to reachable prefixes
79    pub const fn is_reachable(&self) -> bool {
80        self.next_hop.is_some()
81    }
82
83    /// Get the address of the next hop indicated by this NLRI, resolving
84    /// RFC 2545 pairs by scope via [`NextHopAddress::global_addr`].
85    ///
86    /// Panics if used on a unreachable NLRI message (ie. there is no next hop).
87    pub const fn next_hop_addr(&self) -> IpAddr {
88        match self.next_hop {
89            Some(next_hop) => next_hop.global_addr(),
90            None => panic!("unreachable NLRI"),
91        }
92    }
93
94    pub fn new_reachable(prefix: NetworkPrefix, next_hop: Option<IpAddr>) -> Nlri {
95        let next_hop = next_hop.map(NextHopAddress::from);
96        let afi = match prefix.prefix {
97            IpNet::V4(_) => Afi::Ipv4,
98            IpNet::V6(_) => Afi::Ipv6,
99        };
100        let safi = Safi::Unicast;
101        Nlri {
102            afi,
103            safi,
104            next_hop,
105            prefixes: vec![prefix],
106            labeled_prefixes: None,
107            link_state_nlris: None,
108            flowspec_nlris: None,
109            evpn_nlris: None,
110        }
111    }
112
113    pub fn new_unreachable(prefix: NetworkPrefix) -> Nlri {
114        let afi = match prefix.prefix {
115            IpNet::V4(_) => Afi::Ipv4,
116            IpNet::V6(_) => Afi::Ipv6,
117        };
118        let safi = Safi::Unicast;
119        Nlri {
120            afi,
121            safi,
122            next_hop: None,
123            prefixes: vec![prefix],
124            labeled_prefixes: None,
125            link_state_nlris: None,
126            flowspec_nlris: None,
127            evpn_nlris: None,
128        }
129    }
130
131    pub fn new_link_state_reachable(
132        next_hop: Option<IpAddr>,
133        safi: Safi,
134        nlri_list: Vec<crate::models::bgp::linkstate::LinkStateNlri>,
135    ) -> Nlri {
136        let next_hop = next_hop.map(NextHopAddress::from);
137        Nlri {
138            afi: Afi::LinkState,
139            safi,
140            next_hop,
141            prefixes: Vec::new(),
142            labeled_prefixes: None,
143            link_state_nlris: Some(nlri_list),
144            flowspec_nlris: None,
145            evpn_nlris: None,
146        }
147    }
148
149    pub fn new_link_state_unreachable(
150        safi: Safi,
151        nlri_list: Vec<crate::models::bgp::linkstate::LinkStateNlri>,
152    ) -> Nlri {
153        Nlri {
154            afi: Afi::LinkState,
155            safi,
156            next_hop: None,
157            prefixes: Vec::new(),
158            labeled_prefixes: None,
159            link_state_nlris: Some(nlri_list),
160            flowspec_nlris: None,
161            evpn_nlris: None,
162        }
163    }
164
165    /// Create a new Flow-Spec reachable NLRI
166    pub fn new_flowspec_reachable(
167        afi: Afi,
168        safi: Safi,
169        next_hop: Option<IpAddr>,
170        flowspec_nlris: Vec<crate::models::bgp::flowspec::FlowSpecNlri>,
171    ) -> Nlri {
172        let next_hop = next_hop.map(NextHopAddress::from);
173        Nlri {
174            afi,
175            safi,
176            next_hop,
177            prefixes: Vec::new(),
178            labeled_prefixes: None,
179            link_state_nlris: None,
180            flowspec_nlris: Some(flowspec_nlris),
181            evpn_nlris: None,
182        }
183    }
184
185    /// Create a new Flow-Spec unreachable NLRI
186    pub fn new_flowspec_unreachable(
187        afi: Afi,
188        safi: Safi,
189        flowspec_nlris: Vec<crate::models::bgp::flowspec::FlowSpecNlri>,
190    ) -> Nlri {
191        Nlri {
192            afi,
193            safi,
194            next_hop: None,
195            prefixes: Vec::new(),
196            labeled_prefixes: None,
197            link_state_nlris: None,
198            flowspec_nlris: Some(flowspec_nlris),
199            evpn_nlris: None,
200        }
201    }
202
203    /// Create a new MPLS-labeled reachable NLRI (SAFI 4) - RFC 3107/8277
204    pub fn new_labeled_reachable(
205        afi: Afi,
206        next_hop: Option<IpAddr>,
207        labeled_prefixes: Vec<LabeledNetworkPrefix>,
208    ) -> Nlri {
209        let next_hop = next_hop.map(NextHopAddress::from);
210        Nlri {
211            afi,
212            safi: Safi::MplsLabel,
213            next_hop,
214            prefixes: Vec::new(),
215            labeled_prefixes: Some(labeled_prefixes),
216            link_state_nlris: None,
217            flowspec_nlris: None,
218            evpn_nlris: None,
219        }
220    }
221
222    /// Create a new EVPN reachable NLRI (AFI 25 / SAFI 70) - RFC 7432
223    pub fn new_evpn_reachable(
224        next_hop: Option<IpAddr>,
225        nlri_list: Vec<crate::models::bgp::evpn::EvpnNlri>,
226    ) -> Nlri {
227        let next_hop = next_hop.map(NextHopAddress::from);
228        Nlri {
229            afi: Afi::L2vpn,
230            safi: Safi::Evpn,
231            next_hop,
232            prefixes: Vec::new(),
233            labeled_prefixes: None,
234            link_state_nlris: None,
235            flowspec_nlris: None,
236            evpn_nlris: Some(nlri_list),
237        }
238    }
239
240    /// Create a new EVPN unreachable NLRI (AFI 25 / SAFI 70) - RFC 7432
241    pub fn new_evpn_unreachable(nlri_list: Vec<crate::models::bgp::evpn::EvpnNlri>) -> Nlri {
242        Nlri {
243            afi: Afi::L2vpn,
244            safi: Safi::Evpn,
245            next_hop: None,
246            prefixes: Vec::new(),
247            labeled_prefixes: None,
248            link_state_nlris: None,
249            flowspec_nlris: None,
250            evpn_nlris: Some(nlri_list),
251        }
252    }
253
254    /// Create a new MPLS-labeled unreachable NLRI (SAFI 4) - RFC 3107/8277
255    /// Note: Withdrawals use standard prefixes (no label semantics per RFC 8277 ยง2.4)
256    pub fn new_labeled_unreachable(afi: Afi, prefixes: Vec<NetworkPrefix>) -> Nlri {
257        Nlri {
258            afi,
259            safi: Safi::MplsLabel,
260            next_hop: None,
261            prefixes,
262            labeled_prefixes: None,
263            link_state_nlris: None,
264            flowspec_nlris: None,
265            evpn_nlris: None,
266        }
267    }
268}
269
270/// Iterator over all prefixes in the NLRI.
271///
272/// **Note**: This iterator intentionally flattens both traditional prefixes and
273/// labeled prefixes into `IpNet`, discarding MPLS labels and path IDs. This preserves
274/// backward compatibility for users expecting only `IpNet`, but means label information
275/// is not accessible through iteration. To access labels, use `Nlri::labeled_prefixes` directly.
276impl IntoIterator for Nlri {
277    type Item = IpNet;
278    type IntoIter = std::vec::IntoIter<IpNet>;
279
280    fn into_iter(self) -> Self::IntoIter {
281        let mut result: Vec<IpNet> = self.prefixes.into_iter().map(|x| x.prefix).collect();
282
283        // Include labeled prefixes (extract the inner prefix field)
284        if let Some(labeled) = self.labeled_prefixes {
285            for labeled_prefix in labeled {
286                result.push(labeled_prefix.prefix);
287            }
288        }
289
290        result.into_iter()
291    }
292}
293
294impl<'a> IntoIterator for &'a Nlri {
295    type Item = &'a IpNet;
296    type IntoIter = std::vec::IntoIter<&'a IpNet>;
297
298    fn into_iter(self) -> Self::IntoIter {
299        let mut result: Vec<&'a IpNet> = self.prefixes.iter().map(|x| &x.prefix).collect();
300
301        // Include labeled prefixes (extract the inner prefix field)
302        if let Some(ref labeled) = self.labeled_prefixes {
303            for labeled_prefix in labeled {
304                result.push(&labeled_prefix.prefix);
305            }
306        }
307
308        result.into_iter()
309    }
310}
311
312#[derive(Debug, PartialEq, Clone, Eq)]
313#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
314pub struct MpReachableNlri {
315    afi: Afi,
316    safi: Safi,
317    next_hop: NextHopAddress,
318    prefixes: Vec<NetworkPrefix>,
319}
320
321impl MpReachableNlri {
322    pub fn new(
323        afi: Afi,
324        safi: Safi,
325        next_hop: NextHopAddress,
326        prefixes: Vec<NetworkPrefix>,
327    ) -> MpReachableNlri {
328        MpReachableNlri {
329            afi,
330            safi,
331            next_hop,
332            prefixes,
333        }
334    }
335}
336
337#[derive(Debug, PartialEq, Clone, Eq)]
338#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
339pub struct MpUnreachableNlri {
340    afi: Afi,
341    safi: Safi,
342    prefixes: Vec<NetworkPrefix>,
343}
344
345impl MpUnreachableNlri {
346    pub fn new(afi: Afi, safi: Safi, prefixes: Vec<NetworkPrefix>) -> MpUnreachableNlri {
347        MpUnreachableNlri {
348            afi,
349            safi,
350            prefixes,
351        }
352    }
353}
354
355#[cfg(test)]
356mod tests {
357    use super::*;
358    use std::str::FromStr;
359
360    #[test]
361    fn nlri_is_ipv4() {
362        let nlri = Nlri::new_reachable(
363            NetworkPrefix::from_str("10.0.2.0/24").unwrap(),
364            Some("10.0.2.1".parse().unwrap()),
365        );
366
367        assert!(nlri.is_ipv4());
368    }
369
370    #[test]
371    fn nlri_is_ipv6() {
372        let nlri = Nlri::new_unreachable(NetworkPrefix::from_str("2001:db8::/32").unwrap());
373
374        assert!(nlri.is_ipv6());
375    }
376
377    #[test]
378    fn nlri_is_reachable() {
379        let nlri = Nlri::new_reachable(
380            NetworkPrefix::from_str("10.0.2.0/24").unwrap(),
381            Some("10.0.2.1".parse().unwrap()),
382        );
383
384        assert!(nlri.is_reachable());
385    }
386
387    #[test]
388    #[should_panic]
389    fn nlri_next_hop_addr_unreachable() {
390        let nlri = Nlri::new_unreachable(NetworkPrefix::from_str("10.0.2.0/24").unwrap());
391
392        let _ = nlri.next_hop_addr();
393    }
394
395    #[test]
396    fn mp_reachable_nlri_new() {
397        let next_hop_addr = IpAddr::from_str("10.0.2.1").unwrap();
398        let nlri = MpReachableNlri::new(
399            Afi::Ipv4,
400            Safi::Unicast,
401            NextHopAddress::from(next_hop_addr),
402            vec![NetworkPrefix::from_str("10.0.2.0/24").unwrap()],
403        );
404
405        assert_eq!(nlri.afi, Afi::Ipv4);
406        assert_eq!(nlri.safi, Safi::Unicast);
407        assert_eq!(nlri.next_hop.addr(), next_hop_addr);
408        assert_eq!(nlri.prefixes.len(), 1);
409    }
410
411    #[test]
412    fn mp_unreachable_nlri_new() {
413        let nlri = MpUnreachableNlri::new(
414            Afi::Ipv4,
415            Safi::Unicast,
416            vec![NetworkPrefix::from_str("10.0.2.0/24").unwrap()],
417        );
418
419        assert_eq!(nlri.afi, Afi::Ipv4);
420        assert_eq!(nlri.safi, Safi::Unicast);
421        assert_eq!(nlri.prefixes.len(), 1);
422    }
423
424    #[test]
425    fn nlri_link_state_creation() {
426        use crate::models::bgp::linkstate::{LinkStateNlri, NodeDescriptor, ProtocolId};
427
428        let node_desc = NodeDescriptor {
429            autonomous_system: Some(65001),
430            ..Default::default()
431        };
432
433        let ls_nlri = LinkStateNlri::new_node_nlri(ProtocolId::Ospfv2, 123456, node_desc);
434        let nlri = Nlri::new_link_state_reachable(
435            Some("192.168.1.1".parse().unwrap()),
436            Safi::LinkState,
437            vec![ls_nlri],
438        );
439
440        assert!(nlri.is_link_state());
441        assert!(nlri.is_reachable());
442        assert_eq!(nlri.afi, Afi::LinkState);
443        assert_eq!(nlri.safi, Safi::LinkState);
444    }
445
446    #[test]
447    fn nlri_link_state_unreachable() {
448        use crate::models::bgp::linkstate::{LinkStateNlri, NodeDescriptor, ProtocolId};
449
450        let node_desc = NodeDescriptor::default();
451        let ls_nlri = LinkStateNlri::new_node_nlri(ProtocolId::Ospfv2, 123456, node_desc);
452        let nlri = Nlri::new_link_state_unreachable(Safi::LinkState, vec![ls_nlri]);
453
454        assert!(nlri.is_link_state());
455        assert!(!nlri.is_reachable());
456        assert_eq!(nlri.afi, Afi::LinkState);
457        assert_eq!(nlri.safi, Safi::LinkState);
458    }
459
460    #[test]
461    #[should_panic]
462    fn nlri_link_state_next_hop_addr_unreachable() {
463        use crate::models::bgp::linkstate::{LinkStateNlri, NodeDescriptor, ProtocolId};
464
465        let node_desc = NodeDescriptor::default();
466        let ls_nlri = LinkStateNlri::new_node_nlri(ProtocolId::Ospfv2, 123456, node_desc);
467        let nlri = Nlri::new_link_state_unreachable(Safi::LinkState, vec![ls_nlri]);
468
469        let _ = nlri.next_hop_addr();
470    }
471
472    #[test]
473    fn nlri_flowspec_creation() {
474        use crate::models::bgp::flowspec::{FlowSpecComponent, FlowSpecNlri};
475        use std::str::FromStr;
476
477        let component =
478            FlowSpecComponent::DestinationPrefix(NetworkPrefix::from_str("192.0.2.0/24").unwrap());
479        let flowspec_nlri = FlowSpecNlri::new(vec![component]);
480
481        let nlri = Nlri::new_flowspec_reachable(
482            Afi::Ipv4,
483            Safi::FlowSpec,
484            Some("192.0.2.1".parse().unwrap()),
485            vec![flowspec_nlri],
486        );
487
488        assert!(nlri.is_flowspec());
489        assert!(nlri.is_reachable());
490        assert!(nlri.is_ipv4());
491        assert_eq!(nlri.afi, Afi::Ipv4);
492        assert_eq!(nlri.safi, Safi::FlowSpec);
493        assert_eq!(nlri.prefixes.len(), 0); // Flow-Spec doesn't use traditional prefixes
494        assert!(nlri.flowspec_nlris.is_some());
495        assert_eq!(nlri.flowspec_nlris.as_ref().unwrap().len(), 1);
496    }
497
498    #[test]
499    fn nlri_flowspec_unreachable() {
500        use crate::models::bgp::flowspec::{FlowSpecComponent, FlowSpecNlri};
501        use std::str::FromStr;
502
503        let component =
504            FlowSpecComponent::DestinationPrefix(NetworkPrefix::from_str("2001:db8::/32").unwrap());
505        let flowspec_nlri = FlowSpecNlri::new(vec![component]);
506
507        let nlri = Nlri::new_flowspec_unreachable(Afi::Ipv6, Safi::FlowSpec, vec![flowspec_nlri]);
508
509        assert!(nlri.is_flowspec());
510        assert!(!nlri.is_reachable());
511        assert!(nlri.is_ipv6());
512        assert_eq!(nlri.afi, Afi::Ipv6);
513        assert_eq!(nlri.safi, Safi::FlowSpec);
514        assert!(nlri.flowspec_nlris.is_some());
515        assert_eq!(nlri.flowspec_nlris.as_ref().unwrap().len(), 1);
516    }
517
518    #[test]
519    fn nlri_flowspec_l3vpn() {
520        use crate::models::bgp::flowspec::{FlowSpecComponent, FlowSpecNlri, NumericOperator};
521        use std::str::FromStr;
522
523        let components = vec![
524            FlowSpecComponent::DestinationPrefix(NetworkPrefix::from_str("10.0.0.0/8").unwrap()),
525            FlowSpecComponent::IpProtocol(vec![NumericOperator::equal_to(6)]), // TCP
526        ];
527        let flowspec_nlri = FlowSpecNlri::new(components);
528
529        let nlri = Nlri::new_flowspec_reachable(
530            Afi::Ipv4,
531            Safi::FlowSpecL3Vpn,
532            None, // Flow-Spec often doesn't have next hop
533            vec![flowspec_nlri],
534        );
535
536        assert!(nlri.is_flowspec());
537        assert!(!nlri.is_reachable());
538        assert!(nlri.is_ipv4());
539        assert_eq!(nlri.safi, Safi::FlowSpecL3Vpn);
540    }
541
542    #[test]
543    #[should_panic]
544    fn nlri_flowspec_next_hop_addr_unreachable() {
545        use crate::models::bgp::flowspec::{FlowSpecComponent, FlowSpecNlri};
546        use std::str::FromStr;
547
548        let component =
549            FlowSpecComponent::DestinationPrefix(NetworkPrefix::from_str("192.0.2.0/24").unwrap());
550        let flowspec_nlri = FlowSpecNlri::new(vec![component]);
551
552        let nlri = Nlri::new_flowspec_unreachable(Afi::Ipv4, Safi::FlowSpec, vec![flowspec_nlri]);
553
554        let _ = nlri.next_hop_addr();
555    }
556}