1use crate::models::*;
2use ipnet::IpNet;
3use std::fmt::Debug;
4use std::net::IpAddr;
5
6#[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 #[cfg_attr(
18 feature = "ts-rs",
19 ts(type = "(string | { prefix: string; path_id: number })[]")
20 )]
21 pub prefixes: Vec<NetworkPrefix>,
22 #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
25 pub labeled_prefixes: Option<Vec<LabeledNetworkPrefix>>,
26 #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
28 pub link_state_nlris: Option<Vec<crate::models::bgp::linkstate::LinkStateNlri>>,
29 #[cfg_attr(feature = "ts-rs", ts(type = "Record<string, unknown>[] | null"))]
31 pub flowspec_nlris: Option<Vec<crate::models::bgp::flowspec::FlowSpecNlri>>,
32 #[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 pub const fn is_ipv4(&self) -> bool {
40 matches!(self.afi, Afi::Ipv4)
41 }
42
43 pub const fn is_ipv6(&self) -> bool {
45 matches!(self.afi, Afi::Ipv6)
46 }
47
48 pub const fn is_link_state(&self) -> bool {
50 matches!(self.afi, Afi::LinkState)
51 }
52
53 pub const fn is_flowspec(&self) -> bool {
55 matches!(self.safi, Safi::FlowSpec | Safi::FlowSpecL3Vpn)
56 }
57
58 pub const fn is_evpn(&self) -> bool {
60 matches!(self.afi, Afi::L2vpn) && matches!(self.safi, Safi::Evpn)
61 }
62
63 pub const fn is_mpls_labeled(&self) -> bool {
65 matches!(self.safi, Safi::MplsLabel)
66 }
67
68 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 pub const fn is_reachable(&self) -> bool {
80 self.next_hop.is_some()
81 }
82
83 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 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 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 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 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 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 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
270impl 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 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 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); 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)]), ];
527 let flowspec_nlri = FlowSpecNlri::new(components);
528
529 let nlri = Nlri::new_flowspec_reachable(
530 Afi::Ipv4,
531 Safi::FlowSpecL3Vpn,
532 None, 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}