use crate::encoder::sink::put_u8_len_slice;
use crate::error::EncodingError;
use crate::models::*;
use crate::parser::bgp::attributes::attr_03_next_hop::{encode_mp_next_hop, parse_mp_next_hop};
use crate::parser::bgp::attributes::attr_29_linkstate::parse_link_state_nlri;
use crate::parser::{parse_nlri_list, ReadUtils};
use crate::ParserError;
use bytes::{Buf, BufMut, Bytes, BytesMut};
use std::net::IpAddr;
use log::warn;
pub fn parse_nlri(
mut input: Bytes,
afi: &Option<Afi>,
safi: &Option<Safi>,
prefixes: &Option<&[NetworkPrefix]>,
reachable: bool, additional_paths: bool, ) -> Result<AttributeValue, ParserError> {
let first_byte_zero = input.first().map(|b| *b == 0).unwrap_or(false);
let afi = match afi {
Some(afi) => {
if first_byte_zero {
input.read_afi()?
} else {
afi.to_owned()
}
}
None => input.read_afi()?,
};
let safi = match safi {
Some(safi) => {
if first_byte_zero {
input.read_safi()?
} else {
safi.to_owned()
}
}
None => input.read_safi()?,
};
let mut next_hop = None;
if reachable {
let next_hop_length = input.read_u8()? as usize;
input.has_n_remaining(next_hop_length)?;
let next_hop_bytes = input.split_to(next_hop_length);
next_hop = parse_mp_next_hop(next_hop_bytes)?;
}
let (prefixes, labeled_prefixes, link_state_nlris, evpn_nlris) =
if afi == Afi::L2vpn && safi == Safi::Evpn {
if reachable && input.read_u8()? != 0 {
warn!("NLRI reserved byte not 0 (parsing EVPN NLRI)");
}
let nlris = parse_evpn_nlri(&mut input, additional_paths)?;
(Vec::new(), None, None, Some(nlris))
} else if afi == Afi::L2vpn || safi == Safi::Evpn {
return Err(ParserError::Unsupported(format!(
"unsupported address family combination {afi:?}/{safi:?}"
)));
} else if afi == Afi::LinkState && (safi == Safi::LinkState || safi == Safi::LinkStateVpn) {
if reachable {
if input.read_u8()? != 0 {
warn!("NLRI reserved byte not 0 (parsing NLRI Link-State)");
}
}
let ls_nlri = parse_link_state_nlri(input, afi, safi, next_hop, reachable)?;
let link_state_list = ls_nlri.link_state_nlris;
(Vec::new(), None, link_state_list, None)
} else if safi == Safi::MplsLabel {
let config = LabeledNlriConfig {
add_path: additional_paths,
mode: LabeledNlriMode::MultiLabel, max_labels: 16,
peer_max_labels: None,
};
if reachable {
if input.read_u8()? != 0 {
warn!("NLRI reserved byte not 0 (parsing MPLS-labeled NLRI)");
}
let labeled = parse_labeled_nlri(&mut input, afi, &config)?;
(Vec::new(), Some(labeled), None, None)
} else {
let prefixes = parse_labeled_withdrawal_nlri(&mut input, afi, &config)?;
(prefixes, None, None, None)
}
} else {
let prefixes = match prefixes {
Some(pfxs) => {
if first_byte_zero {
if reachable {
if input.read_u8()? != 0 {
warn!("NLRI reserved byte not 0 (parsing NLRI prefixes)");
}
}
parse_nlri_list(input, additional_paths, &afi)?
} else {
pfxs.to_vec()
}
}
None => {
if reachable {
if input.read_u8()? != 0 {
warn!("NLRI reserved byte not 0 (parsing NLRI prefixes)");
}
}
parse_nlri_list(input, additional_paths, &afi)?
}
};
(prefixes, None, None, None)
};
let nlri = Nlri {
afi,
safi,
next_hop,
prefixes,
labeled_prefixes,
link_state_nlris,
flowspec_nlris: None,
evpn_nlris,
};
match reachable {
true => Ok(AttributeValue::MpReachNlri(nlri)),
false => Ok(AttributeValue::MpUnreachNlri(nlri)),
}
}
fn parse_evpn_nlri(
input: &mut Bytes,
additional_paths: bool,
) -> Result<Vec<EvpnNlri>, ParserError> {
let mut nlris = Vec::new();
while input.remaining() > 0 {
let path_id = if additional_paths {
Some(input.read_u32()?)
} else {
None
};
let route_type = EvpnRouteType::from(input.read_u8()?);
let body_len = input.read_u8()? as usize;
input.has_n_remaining(body_len)?;
let mut body = input.split_to(body_len);
if body.remaining() < 8 {
return Err(ParserError::ParseError(
"EVPN NLRI shorter than a route distinguisher".to_string(),
));
}
let mut rd = [0u8; 8];
body.copy_to_slice(&mut rd);
let route_distinguisher = RouteDistinguisher(rd);
let payload = match route_type {
EvpnRouteType::MacIpAdvertisement => {
EvpnRoutePayload::MacIpAdvertisement(parse_mac_ip_advertisement(&mut body)?)
}
EvpnRouteType::InclusiveMulticastEthernetTag => {
EvpnRoutePayload::InclusiveMulticast(parse_inclusive_multicast(&mut body)?)
}
EvpnRouteType::IpPrefix => {
EvpnRoutePayload::IpPrefix(parse_ip_prefix_route(&mut body)?)
}
_ => EvpnRoutePayload::Raw(body.to_vec()),
};
nlris.push(EvpnNlri {
path_id,
route_type,
route_distinguisher,
payload,
});
}
Ok(nlris)
}
fn parse_mac_ip_advertisement(body: &mut Bytes) -> Result<MacIpAdvertisement, ParserError> {
if body.remaining() < 10 + 4 + 1 + 6 + 1 + 3 {
return Err(ParserError::ParseError(
"EVPN type 2 NLRI too short for the fixed fields".to_string(),
));
}
let mut esi = [0u8; 10];
body.copy_to_slice(&mut esi);
let ethernet_tag_id = body.read_u32()?;
let mac_len = body.read_u8()?;
if mac_len != 48 {
return Err(ParserError::ParseError(format!(
"EVPN type 2 MAC address length {mac_len} is not 48"
)));
}
let mut mac = [0u8; 6];
body.copy_to_slice(&mut mac);
let ip_len = body.read_u8()?;
let ip = match ip_len {
0 => None,
32 => Some(IpAddr::V4(body.read_ipv4_address()?)),
128 => Some(IpAddr::V6(body.read_ipv6_address()?)),
other => {
return Err(ParserError::ParseError(format!(
"EVPN type 2 IP address length {other} is not 0, 32 or 128"
)))
}
};
let raw_label = read_three_octet_label(body)?;
let raw_label2 = if body.remaining() == 3 {
Some(read_three_octet_label(body)?)
} else {
None
};
if body.remaining() != 0 {
return Err(ParserError::ParseError(format!(
"EVPN type 2 NLRI has {} trailing octets",
body.remaining()
)));
}
Ok(MacIpAdvertisement {
esi,
ethernet_tag_id,
mac,
ip,
raw_label,
raw_label2,
})
}
fn parse_inclusive_multicast(body: &mut Bytes) -> Result<InclusiveMulticastRoute, ParserError> {
if body.remaining() < 4 + 1 {
return Err(ParserError::ParseError(
"EVPN type 3 NLRI too short".to_string(),
));
}
let ethernet_tag_id = body.read_u32()?;
let ip_len = body.read_u8()?;
let originating_router_ip = match ip_len {
32 => IpAddr::V4(body.read_ipv4_address()?),
128 => IpAddr::V6(body.read_ipv6_address()?),
other => {
return Err(ParserError::ParseError(format!(
"EVPN type 3 originating router IP length {other} is not 32 or 128"
)))
}
};
if body.remaining() != 0 {
return Err(ParserError::ParseError(format!(
"EVPN type 3 NLRI has {} trailing octets",
body.remaining()
)));
}
Ok(InclusiveMulticastRoute {
ethernet_tag_id,
originating_router_ip,
})
}
fn parse_ip_prefix_route(body: &mut Bytes) -> Result<IpPrefixRoute, ParserError> {
let is_ipv6 = match body.len() {
26 => false,
50 => true,
other => {
return Err(ParserError::ParseError(format!(
"EVPN type 5 payload is {other} octets after the route distinguisher, not 26 (IPv4) or 50 (IPv6)"
)))
}
};
let mut esi = [0u8; 10];
body.copy_to_slice(&mut esi);
let ethernet_tag_id = body.read_u32()?;
let prefix_len = body.read_u8()?;
let max_len = if is_ipv6 { 128 } else { 32 };
if prefix_len > max_len {
return Err(ParserError::ParseError(format!(
"EVPN type 5 prefix length {prefix_len} is invalid for an {is_ipv6} prefix"
)));
}
let ip_prefix = if is_ipv6 {
let addr = body.read_ipv6_address()?;
ipnet::IpNet::new(addr.into(), prefix_len)
} else {
let addr = body.read_ipv4_address()?;
ipnet::IpNet::new(addr.into(), prefix_len)
}
.map_err(|e| ParserError::ParseError(format!("EVPN type 5 invalid prefix: {e}")))?;
let gateway_ip = if is_ipv6 {
IpAddr::V6(body.read_ipv6_address()?)
} else {
IpAddr::V4(body.read_ipv4_address()?)
};
let raw_label = read_three_octet_label(body)?;
if body.remaining() != 0 {
return Err(ParserError::ParseError(format!(
"EVPN type 5 NLRI has {} trailing octets",
body.remaining()
)));
}
Ok(IpPrefixRoute {
esi,
ethernet_tag_id,
ip_prefix,
gateway_ip,
raw_label,
})
}
fn encode_evpn_payload(route: &EvpnNlri) -> Result<Vec<u8>, EncodingError> {
let payload = &route.payload;
let expected = match payload {
EvpnRoutePayload::MacIpAdvertisement(_) => EvpnRouteType::MacIpAdvertisement,
EvpnRoutePayload::InclusiveMulticast(_) => EvpnRouteType::InclusiveMulticastEthernetTag,
EvpnRoutePayload::IpPrefix(_) => EvpnRouteType::IpPrefix,
EvpnRoutePayload::Raw(_) => route.route_type,
};
if expected != route.route_type {
return Err(EncodingError::unencodable(
"EVPN NLRI route type",
format!(
"route type {:?} does not match its {:?} payload",
route.route_type, expected
),
));
}
let mut out = Vec::new();
match payload {
EvpnRoutePayload::MacIpAdvertisement(body) => {
out.extend_from_slice(&body.esi);
out.extend_from_slice(&body.ethernet_tag_id.to_be_bytes());
out.push(48); out.extend_from_slice(&body.mac);
match body.ip {
None => out.push(0),
Some(IpAddr::V4(ip)) => {
out.push(32);
out.extend_from_slice(&ip.octets());
}
Some(IpAddr::V6(ip)) => {
out.push(128);
out.extend_from_slice(&ip.octets());
}
}
push_three_octet(&mut out, body.raw_label, "EVPN Label1")?;
if let Some(label2) = body.raw_label2 {
push_three_octet(&mut out, label2, "EVPN Label2")?;
}
}
EvpnRoutePayload::InclusiveMulticast(body) => {
out.extend_from_slice(&body.ethernet_tag_id.to_be_bytes());
match body.originating_router_ip {
IpAddr::V4(ip) => {
out.push(32);
out.extend_from_slice(&ip.octets());
}
IpAddr::V6(ip) => {
out.push(128);
out.extend_from_slice(&ip.octets());
}
}
}
EvpnRoutePayload::IpPrefix(body) => {
out.extend_from_slice(&body.esi);
out.extend_from_slice(&body.ethernet_tag_id.to_be_bytes());
out.push(body.ip_prefix.prefix_len());
match (&body.ip_prefix, body.gateway_ip) {
(ipnet::IpNet::V4(net), IpAddr::V4(gateway)) => {
out.extend_from_slice(&net.addr().octets());
out.extend_from_slice(&gateway.octets());
}
(ipnet::IpNet::V6(net), IpAddr::V6(gateway)) => {
out.extend_from_slice(&net.addr().octets());
out.extend_from_slice(&gateway.octets());
}
_ => {
return Err(EncodingError::unencodable(
"EVPN IP prefix route",
"the prefix and the gateway address must be of the same family",
))
}
}
push_three_octet(&mut out, body.raw_label, "EVPN MPLS label")?;
}
EvpnRoutePayload::Raw(bytes) => out.extend_from_slice(bytes),
}
Ok(out)
}
fn push_three_octet(
out: &mut Vec<u8>,
value: u32,
field: &'static str,
) -> Result<(), EncodingError> {
if value > 0x00FF_FFFF {
return Err(EncodingError::unencodable(
field,
format!("{value} does not fit 3 octets"),
));
}
out.extend_from_slice(&[(value >> 16) as u8, (value >> 8) as u8, value as u8]);
Ok(())
}
fn read_three_octet_label(body: &mut Bytes) -> Result<u32, ParserError> {
body.has_n_remaining(3)?;
let octets = body.split_to(3);
Ok(u32::from_be_bytes([0, octets[0], octets[1], octets[2]]))
}
pub fn encode_nlri(
nlri: &Nlri,
reachable: bool,
add_path: bool,
bytes: &mut BytesMut,
) -> Result<(), EncodingError> {
if nlri.afi == Afi::L2vpn {
match (reachable, nlri.next_hop) {
(true, None) => {
return Err(EncodingError::unencodable(
"EVPN NLRI next hop",
"an EVPN announcement needs the originating VTEP as next hop",
))
}
(false, Some(_)) => {
return Err(EncodingError::unencodable(
"EVPN NLRI next hop",
"an EVPN withdrawal carries no next hop",
))
}
_ => {}
}
}
bytes.put_u16(nlri.afi as u16);
bytes.put_u8(nlri.safi as u8);
if let Some(next_hop) = &nlri.next_hop {
if !reachable {
warn!("NLRI next hop should not be set for unreachable NLRI (encoding NLRI)");
}
let next_hop_bytes = encode_mp_next_hop(next_hop);
put_u8_len_slice(bytes, "MP NLRI next hop length", &next_hop_bytes)?;
}
if nlri.afi == Afi::L2vpn && nlri.safi == Safi::Evpn {
if reachable {
bytes.put_u8(0);
}
for route in nlri.evpn_nlris.iter().flatten() {
match (add_path, route.path_id) {
(true, Some(path_id)) => bytes.put_u32(path_id),
(true, None) => {
return Err(EncodingError::unencodable(
"EVPN NLRI path id",
"ADD-PATH is requested but the route carries no path identifier",
))
}
(false, Some(_)) => {
return Err(EncodingError::unencodable(
"EVPN NLRI path id",
"the route carries a path identifier but ADD-PATH is not enabled",
))
}
(false, None) => {}
}
let body = encode_evpn_payload(route)?;
let entry_len = 8 + body.len();
if entry_len > u8::MAX as usize {
return Err(EncodingError::unencodable(
"EVPN NLRI length",
format!("{entry_len} octets do not fit the 1-octet length field"),
));
}
bytes.put_u8(u8::from(route.route_type));
bytes.put_u8(entry_len as u8);
bytes.put_slice(&route.route_distinguisher.0);
bytes.extend_from_slice(&body);
}
} else if nlri.afi == Afi::L2vpn {
return Err(EncodingError::unencodable(
"MP NLRI",
"L2VPN NLRI require the EVPN subsequent address family",
));
} else if nlri.safi == Safi::MplsLabel {
if reachable {
bytes.put_u8(0);
}
if let Some(labeled_prefixes) = &nlri.labeled_prefixes {
for labeled in labeled_prefixes {
let mode = if labeled.labels.len() <= 1 {
crate::models::LabeledNlriMode::SingleLabel
} else {
crate::models::LabeledNlriMode::MultiLabel
};
let encoded = crate::models::encode_labeled_prefix(
labeled, mode, add_path, None, )
.map_err(|e| {
EncodingError::unencodable("MP NLRI labeled prefix", format!("{e:?}"))
})?;
bytes.extend_from_slice(&encoded);
}
}
} else if nlri.afi == Afi::LinkState {
if reachable {
bytes.put_u8(0);
}
if let Some(link_state_nlris) = &nlri.link_state_nlris {
for ls_nlri in link_state_nlris {
bytes.put_u16(ls_nlri.nlri_type as u16);
bytes.put_u16(0); }
}
} else {
if reachable {
bytes.put_u8(0);
}
for prefix in &nlri.prefixes {
bytes.extend(prefix.encode());
}
if let Some(flowspec_nlris) = &nlri.flowspec_nlris {
for flowspec in flowspec_nlris {
bytes.put_slice(&encode_flowspec_nlri(flowspec)?);
}
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use ipnet::IpNet;
use std::net::Ipv4Addr;
use std::str::FromStr;
#[test]
fn test_parsing_nlri_simple() {
let test_bytes = Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0xC0, 0x00, 0x02, 0x01, 0x00, 0x18, 0xC0, 0x00, 0x02, ]);
let res = parse_nlri(test_bytes, &None, &None, &None, true, false);
if let Ok(AttributeValue::MpReachNlri(nlri)) = res {
assert_eq!(nlri.afi, Afi::Ipv4);
assert_eq!(nlri.safi, Safi::Unicast);
assert_eq!(
nlri.next_hop,
Some(NextHopAddress::Ipv4(
Ipv4Addr::from_str("192.0.2.1").unwrap()
))
);
assert_eq!(
nlri.prefixes,
vec![NetworkPrefix::from_str("192.0.2.0/24").unwrap()]
);
}
}
#[test]
fn test_parsing_nlri_passed_in_afi() {
let test_bytes = Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0xC0, 0x00, 0x02, 0x01, 0x00, 0x18, 0xC0, 0x00, 0x02, ]);
let res = parse_nlri(
test_bytes,
&Some(Afi::Ipv4),
&Some(Safi::Unicast),
&None,
true,
false,
);
if let Ok(AttributeValue::MpReachNlri(nlri)) = res {
assert_eq!(nlri.afi, Afi::Ipv4);
assert_eq!(nlri.safi, Safi::Unicast);
assert_eq!(
nlri.next_hop,
Some(NextHopAddress::Ipv4(
Ipv4Addr::from_str("192.0.2.1").unwrap()
))
);
assert_eq!(
nlri.prefixes,
vec![NetworkPrefix::from_str("192.0.2.0/24").unwrap()]
);
}
}
#[test]
fn test_parsing_nlri_errors() {
let test_bytes = Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0xC0, 0x00, 0x02, 0x00, 0x18, 0xC0, 0x00, 0x02, ]);
let res = parse_nlri(
test_bytes,
&Some(Afi::Ipv4),
&Some(Safi::Unicast),
&None,
true,
false,
);
assert!(res.is_err());
}
#[test]
fn test_parsing_nlri_add_path() {
let test_bytes = Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0xC0, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x7B, 0x18, 0xC0, 0x00, 0x02, ]);
let res = parse_nlri(test_bytes, &None, &None, &None, true, true);
if let Ok(AttributeValue::MpReachNlri(nlri)) = res {
assert_eq!(nlri.afi, Afi::Ipv4);
assert_eq!(nlri.safi, Safi::Unicast);
assert_eq!(
nlri.next_hop,
Some(NextHopAddress::Ipv4(
Ipv4Addr::from_str("192.0.2.1").unwrap()
))
);
let prefix = NetworkPrefix::new(IpNet::from_str("192.0.2.0/24").unwrap(), Some(123));
assert_eq!(nlri.prefixes[0], prefix);
assert_eq!(nlri.prefixes[0].path_id, prefix.path_id);
} else {
panic!("Unexpected result: {res:?}");
}
}
#[test]
fn test_encode_nlri() {
let nlri = Nlri {
afi: Afi::Ipv4,
safi: Safi::Unicast,
next_hop: Some(NextHopAddress::Ipv4(
Ipv4Addr::from_str("10.0.0.1").unwrap(),
)),
prefixes: vec![NetworkPrefix {
prefix: IpNet::from_str("192.0.1.0/24").unwrap(),
path_id: None,
}],
labeled_prefixes: None,
link_state_nlris: None,
flowspec_nlris: None,
evpn_nlris: None,
};
let mut buf = BytesMut::new();
encode_nlri(&nlri, true, false, &mut buf).unwrap();
let bytes = buf.freeze();
assert_eq!(
bytes,
Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0x0A, 0x00, 0x00, 0x01, 0x00, 0x18, 0xC0, 0x00, 0x01, ])
);
let parsed_nlri = parse_nlri(bytes, &None, &None, &None, true, false).unwrap();
assert_eq!(parsed_nlri, AttributeValue::MpReachNlri(nlri));
let nlri = Nlri {
afi: Afi::Ipv4,
safi: Safi::Unicast,
next_hop: Some(NextHopAddress::Ipv4(
Ipv4Addr::from_str("10.0.0.1").unwrap(),
)),
prefixes: vec![NetworkPrefix {
prefix: IpNet::from_str("192.0.1.0/24").unwrap(),
path_id: Some(123),
}],
labeled_prefixes: None,
link_state_nlris: None,
flowspec_nlris: None,
evpn_nlris: None,
};
let mut buf = BytesMut::new();
encode_nlri(&nlri, true, true, &mut buf).unwrap();
let bytes = buf.freeze();
assert_eq!(
bytes,
Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0x0A, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x7B, 0x18, 0xC0, 0x00, 0x01, ])
);
}
#[test]
fn test_parsing_unreachable_nlri() {
let test_bytes = Bytes::from(vec![
0x00, 0x01, 0x01, 0x18, 0xC0, 0x00, 0x02, ]);
let res = parse_nlri(test_bytes, &None, &None, &None, false, false);
if let Ok(AttributeValue::MpUnreachNlri(nlri)) = res {
assert_eq!(nlri.afi, Afi::Ipv4);
assert_eq!(nlri.safi, Safi::Unicast);
assert_eq!(nlri.next_hop, None);
assert_eq!(
nlri.prefixes,
vec![NetworkPrefix::from_str("192.0.2.0/24").unwrap()]
);
} else {
panic!("Unexpected result: {res:?}");
}
}
#[test]
fn test_encode_unreachable_nlri() {
let nlri = Nlri {
afi: Afi::Ipv4,
safi: Safi::Unicast,
next_hop: None,
prefixes: vec![NetworkPrefix {
prefix: IpNet::from_str("192.0.1.0/24").unwrap(),
path_id: None,
}],
labeled_prefixes: None,
link_state_nlris: None,
flowspec_nlris: None,
evpn_nlris: None,
};
let mut buf = BytesMut::new();
encode_nlri(&nlri, false, false, &mut buf).unwrap();
let bytes = buf.freeze();
assert_eq!(
bytes,
Bytes::from(vec![
0x00, 0x01, 0x01, 0x18, 0xC0, 0x00, 0x01, ])
);
let parsed_nlri = parse_nlri(bytes, &None, &None, &None, false, false).unwrap();
assert_eq!(parsed_nlri, AttributeValue::MpUnreachNlri(nlri));
let nlri_with_next_hop = Nlri {
afi: Afi::Ipv4,
safi: Safi::Unicast,
next_hop: Some(NextHopAddress::Ipv4(
Ipv4Addr::from_str("10.0.0.1").unwrap(),
)),
prefixes: vec![NetworkPrefix {
prefix: IpNet::from_str("192.0.1.0/24").unwrap(),
path_id: None,
}],
labeled_prefixes: None,
link_state_nlris: None,
flowspec_nlris: None,
evpn_nlris: None,
};
let mut buf = BytesMut::new();
encode_nlri(&nlri_with_next_hop, false, false, &mut buf).unwrap();
let bytes = buf.freeze();
assert_eq!(
bytes,
Bytes::from(vec![
0x00, 0x01, 0x01, 0x04, 0x0A, 0x00, 0x00, 0x01, 0x18, 0xC0, 0x00, 0x01, ])
);
}
}
#[cfg(test)]
mod evpn_tests {
use super::*;
use std::str::FromStr;
fn reach(nlri: Vec<u8>) -> Bytes {
let mut bytes = vec![
0x00, 0x19, 0x46, 0x04, 0x0a, 0x00, 0x00, 0x01, 0x00, ];
bytes.extend(nlri);
Bytes::from(bytes)
}
fn unreach(nlri: Vec<u8>) -> Bytes {
let mut bytes = vec![0x00, 0x19, 0x46];
bytes.extend(nlri);
Bytes::from(bytes)
}
fn mac_ip_nlri(ip_length: u8, ip_bytes: &[u8]) -> Vec<u8> {
let body_len = 8 + 10 + 4 + 1 + 6 + 1 + ip_bytes.len() + 3;
let mut nlri = vec![0x02, body_len as u8];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 11, 0, 2]); nlri.extend_from_slice(&[0u8; 10]); nlri.extend_from_slice(&[0, 0, 0, 100]); nlri.extend_from_slice(&[0x30]); nlri.extend_from_slice(&[0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
nlri.push(ip_length);
nlri.extend_from_slice(ip_bytes);
nlri.extend_from_slice(&[0x00, 0x00, 0x64]); nlri
}
#[test]
fn parses_mac_ip_route_with_ipv4() {
let res = parse_nlri(
reach(mac_ip_nlri(32, &[192, 0, 2, 10])),
&None,
&None,
&None,
true,
false,
);
let Ok(AttributeValue::MpReachNlri(nlri)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
assert_eq!(nlri.afi, Afi::L2vpn);
assert_eq!(nlri.safi, Safi::Evpn);
assert!(nlri.is_evpn());
assert_eq!(
nlri.next_hop,
Some(NextHopAddress::Ipv4("10.0.0.1".parse().unwrap()))
);
let routes = nlri.evpn_nlris.expect("EVPN NLRI");
assert_eq!(routes.len(), 1);
assert_eq!(routes[0].route_type, EvpnRouteType::MacIpAdvertisement);
assert_eq!(routes[0].route_distinguisher.0, [0, 1, 10, 10, 0, 11, 0, 2]);
let EvpnRoutePayload::MacIpAdvertisement(body) = &routes[0].payload else {
panic!("expected a MAC/IP advertisement");
};
assert_eq!(body.esi, [0u8; 10]);
assert_eq!(body.ethernet_tag_id, 100);
assert_eq!(body.mac, [0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(body.ip, Some("192.0.2.10".parse().unwrap()));
assert_eq!(body.raw_label, 100);
}
#[test]
fn parses_mac_ip_route_with_ipv6() {
let ip: std::net::Ipv6Addr = "2001:db8::1".parse().unwrap();
let res = parse_nlri(
reach(mac_ip_nlri(128, &ip.octets())),
&None,
&None,
&None,
true,
false,
);
let Ok(AttributeValue::MpReachNlri(nlri)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = nlri.evpn_nlris.expect("EVPN NLRI");
let EvpnRoutePayload::MacIpAdvertisement(body) = &routes[0].payload else {
panic!("expected a MAC/IP advertisement");
};
assert_eq!(body.ip, Some(std::net::IpAddr::V6(ip)));
}
#[test]
fn parses_implicit_route() {
let mut nlri = vec![0x03, 0x11];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 11, 0, 2]); nlri.extend_from_slice(&[0, 0, 0, 100]); nlri.push(32); nlri.extend_from_slice(&[10, 10, 0, 11]);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
let Ok(AttributeValue::MpReachNlri(parsed)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
assert_eq!(
routes[0].route_type,
EvpnRouteType::InclusiveMulticastEthernetTag
);
let EvpnRoutePayload::InclusiveMulticast(body) = &routes[0].payload else {
panic!("expected an IMET route");
};
assert_eq!(body.ethernet_tag_id, 100);
assert_eq!(
body.originating_router_ip,
"10.10.0.11".parse::<IpAddr>().unwrap()
);
}
#[test]
fn parses_ip_prefix_route() {
let mut nlri = vec![0x05, 0x22];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 12, 0, 2]); nlri.extend_from_slice(&[0u8; 10]); nlri.extend_from_slice(&[0, 0, 0, 0]); nlri.push(24); nlri.extend_from_slice(&[198, 51, 100, 0]); nlri.extend_from_slice(&[0, 0, 0, 0]); nlri.extend_from_slice(&[0, 0, 0x64]);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
let Ok(AttributeValue::MpReachNlri(parsed)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
assert_eq!(routes[0].route_type, EvpnRouteType::IpPrefix);
let EvpnRoutePayload::IpPrefix(body) = &routes[0].payload else {
panic!("expected an IP prefix route");
};
assert_eq!(body.esi, [0u8; 10]);
assert_eq!(
body.ip_prefix,
ipnet::IpNet::from_str("198.51.100.0/24").unwrap()
);
assert_eq!(body.gateway_ip, "0.0.0.0".parse::<IpAddr>().unwrap());
assert_eq!(body.raw_label, 100);
}
#[test]
fn parses_ipv6_ip_prefix_route_shorter_than_slash_32() {
let mut nlri = vec![0x05, 0x3a];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 12, 0, 2]); nlri.extend_from_slice(&[0u8; 10]); nlri.extend_from_slice(&[0, 0, 0, 0]); nlri.push(20); nlri.extend_from_slice(&[0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
nlri.extend_from_slice(&[0u8; 16]); nlri.extend_from_slice(&[0, 0, 0x64]);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
let Ok(AttributeValue::MpReachNlri(parsed)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
let EvpnRoutePayload::IpPrefix(body) = &routes[0].payload else {
panic!("expected an IP prefix route");
};
assert_eq!(
body.ip_prefix,
ipnet::IpNet::from_str("2001:db8::/20").unwrap()
);
assert_eq!(body.gateway_ip, "::".parse::<IpAddr>().unwrap());
}
#[test]
fn rejects_ip_prefix_route_with_the_wrong_length() {
let mut nlri = vec![0x05, 0x1a];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 12, 0, 2]); nlri.extend_from_slice(&[0u8; 18]);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
assert!(
res.is_err(),
"a type 5 route of the wrong length must not parse"
);
}
#[test]
fn parses_optional_second_label() {
let mut body = mac_ip_nlri(32, &[192, 0, 2, 10]);
let label2 = [0x00, 0x00, 0x2a];
body[1] += 3; body.extend_from_slice(&label2);
let res = parse_nlri(reach(body), &None, &None, &None, true, false);
let Ok(AttributeValue::MpReachNlri(parsed)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
let EvpnRoutePayload::MacIpAdvertisement(route) = &routes[0].payload else {
panic!("expected a MAC/IP advertisement");
};
assert_eq!(route.raw_label, 100);
assert_eq!(route.raw_label2, Some(42));
}
#[test]
fn rejects_a_mac_address_that_does_not_fit() {
let mut nlri = vec![0x02, 0x17];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 12, 0, 2]); nlri.extend_from_slice(&[0u8; 10]); nlri.extend_from_slice(&[0, 0, 0, 0]); nlri.push(48);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
assert!(res.is_err(), "a truncated MAC must be a parse error");
}
#[test]
fn keeps_the_add_path_identifier() {
let mut nlri = vec![0x00, 0x00, 0x00, 0x07]; nlri.extend_from_slice(&mac_ip_nlri(0, &[]));
let res = parse_nlri(reach(nlri), &None, &None, &None, true, true);
let Ok(AttributeValue::MpReachNlri(parsed)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
assert_eq!(routes[0].path_id, Some(7));
}
#[test]
fn rejects_families_that_mix_l2vpn_or_evpn_with_something_else() {
let bytes = Bytes::from(vec![0x00, 0x01, 0x46, 0x00]);
let res = parse_nlri(bytes, &None, &None, &None, false, false);
assert!(res.is_err(), "ipv4/evpn must not be parsed as prefixes");
let bytes = Bytes::from(vec![0x00, 0x19, 0x01, 0x00]);
let res = parse_nlri(bytes, &None, &None, &None, false, false);
assert!(res.is_err(), "l2vpn/unicast must not be parsed as prefixes");
}
#[test]
fn keeps_undecoded_route_types_as_raw_bytes() {
let mut nlri = vec![0x06, 0x0a];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 12, 0, 2]);
nlri.extend_from_slice(&[0xde, 0xad]);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
let Ok(AttributeValue::MpReachNlri(parsed)) = res else {
panic!("expected MP_REACH_NLRI, got {res:?}");
};
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
assert_eq!(routes[0].route_type, EvpnRouteType::Unknown(6));
assert_eq!(routes[0].payload, EvpnRoutePayload::Raw(vec![0xde, 0xad]));
}
#[test]
fn parses_withdrawals_and_end_of_rib() {
let res = parse_nlri(
unreach(mac_ip_nlri(0, &[])),
&None,
&None,
&None,
false,
false,
);
let Ok(AttributeValue::MpUnreachNlri(parsed)) = res else {
panic!("expected MP_UNREACH_NLRI, got {res:?}");
};
assert_eq!(parsed.next_hop, None);
let routes = parsed.evpn_nlris.expect("EVPN NLRI");
assert_eq!(routes.len(), 1);
let res = parse_nlri(unreach(vec![]), &None, &None, &None, false, false);
let Ok(AttributeValue::MpUnreachNlri(parsed)) = res else {
panic!("expected MP_UNREACH_NLRI, got {res:?}");
};
assert_eq!(parsed.evpn_nlris, Some(vec![]));
}
#[test]
fn evpn_nlri_round_trips_through_the_encoder() {
let wire = reach(mac_ip_nlri(32, &[192, 0, 2, 10]));
let Ok(AttributeValue::MpReachNlri(parsed)) =
parse_nlri(wire.clone(), &None, &None, &None, true, false)
else {
panic!("expected MP_REACH_NLRI");
};
let mut buf = BytesMut::new();
encode_nlri(&parsed, true, false, &mut buf).expect("EVPN encoding");
let encoded = buf.freeze();
assert_eq!(encoded, wire, "encoding reproduces the wire bytes");
let again = parse_nlri(encoded, &None, &None, &None, true, false).unwrap();
assert_eq!(again, AttributeValue::MpReachNlri(parsed));
}
#[test]
fn evpn_type_5_round_trips_through_the_encoder() {
let mut nlri = vec![0x05, 0x22];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 12, 0, 2]); nlri.extend_from_slice(&[0u8; 10]); nlri.extend_from_slice(&[0, 0, 0, 0]); nlri.push(24); nlri.extend_from_slice(&[198, 51, 100, 0]);
nlri.extend_from_slice(&[0, 0, 0, 0]);
nlri.extend_from_slice(&[0, 0, 0x64]); let wire = reach(nlri);
let Ok(AttributeValue::MpReachNlri(parsed)) =
parse_nlri(wire.clone(), &None, &None, &None, true, false)
else {
panic!("expected MP_REACH_NLRI");
};
let mut buf = BytesMut::new();
encode_nlri(&parsed, true, false, &mut buf).unwrap();
assert_eq!(buf.freeze(), wire);
}
#[test]
fn evpn_add_path_round_trips_preserving_the_path_id() {
let mut nlri = vec![0x00, 0x00, 0x00, 0x07]; nlri.extend_from_slice(&mac_ip_nlri(0, &[]));
let wire = reach(nlri);
let Ok(AttributeValue::MpReachNlri(parsed)) =
parse_nlri(wire.clone(), &None, &None, &None, true, true)
else {
panic!("expected MP_REACH_NLRI");
};
assert_eq!(
parsed.evpn_nlris.as_ref().and_then(|r| r[0].path_id),
Some(7)
);
let mut buf = BytesMut::new();
encode_nlri(&parsed, true, true, &mut buf).unwrap();
assert_eq!(buf.freeze(), wire);
let mut buf = BytesMut::new();
let err = encode_nlri(&parsed, true, false, &mut buf)
.expect_err("ADD-PATH state and path identifiers must agree");
assert!(format!("{err:?}").contains("path identifier"));
}
#[test]
fn rejects_trailing_octets_in_an_implicit_route() {
let mut nlri = vec![0x03, 0x13];
nlri.extend_from_slice(&[0x00, 0x01, 10, 10, 0, 11, 0, 2]); nlri.extend_from_slice(&[0, 0, 0, 100]); nlri.push(32);
nlri.extend_from_slice(&[10, 10, 0, 11]);
nlri.extend_from_slice(&[0xde, 0xad]);
let res = parse_nlri(reach(nlri), &None, &None, &None, true, false);
assert!(res.is_err(), "trailing octets must not be dropped silently");
}
#[test]
fn refuses_evpn_next_hop_states_that_do_not_exist_on_the_wire() {
let route = EvpnNlri {
path_id: None,
route_type: EvpnRouteType::MacIpAdvertisement,
route_distinguisher: RouteDistinguisher([0, 1, 10, 10, 0, 11, 0, 2]),
payload: EvpnRoutePayload::MacIpAdvertisement(MacIpAdvertisement {
esi: [0; 10],
ethernet_tag_id: 0,
mac: [0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff],
ip: None,
raw_label: 100,
raw_label2: None,
}),
};
let announcement = Nlri::new_evpn_reachable(None, vec![route.clone()]);
let mut buf = BytesMut::new();
let err = encode_nlri(&announcement, true, false, &mut buf)
.expect_err("a reachable EVPN NLRI needs a next hop");
assert!(format!("{err:?}").contains("next hop"), "{err:?}");
assert!(buf.is_empty(), "nothing is written before the refusal");
let withdrawal = Nlri::new_evpn_reachable(Some("10.10.0.11".parse().unwrap()), vec![route]);
let mut buf = BytesMut::new();
let err = encode_nlri(&withdrawal, false, false, &mut buf)
.expect_err("an EVPN withdrawal carries no next hop");
assert!(format!("{err:?}").contains("no next hop"), "{err:?}");
}
#[test]
fn refuses_a_route_type_that_disagrees_with_its_payload() {
let route = EvpnNlri {
path_id: None,
route_type: EvpnRouteType::IpPrefix,
route_distinguisher: RouteDistinguisher([0, 1, 10, 10, 0, 11, 0, 2]),
payload: EvpnRoutePayload::MacIpAdvertisement(MacIpAdvertisement {
esi: [0; 10],
ethernet_tag_id: 0,
mac: [0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff],
ip: None,
raw_label: 100,
raw_label2: None,
}),
};
let nlri = Nlri::new_evpn_reachable(Some("10.10.0.11".parse().unwrap()), vec![route]);
let mut buf = BytesMut::new();
let err = encode_nlri(&nlri, true, false, &mut buf)
.expect_err("the route type and payload must agree");
assert!(format!("{err:?}").contains("route type"), "{err:?}");
}
#[test]
fn the_attribute_encoder_keeps_add_path_state_for_evpn() {
let route = EvpnNlri {
path_id: Some(7),
route_type: EvpnRouteType::MacIpAdvertisement,
route_distinguisher: RouteDistinguisher([0, 1, 10, 10, 0, 12, 0, 2]),
payload: EvpnRoutePayload::MacIpAdvertisement(MacIpAdvertisement {
esi: [0; 10],
ethernet_tag_id: 0,
mac: [0xaa, 0xc1, 0xab, 0x73, 0x01, 0x4d],
ip: None,
raw_label: 100,
raw_label2: None,
}),
};
let announced = AttributeValue::MpReachNlri(Nlri::new_evpn_reachable(
Some("10.10.0.12".parse().unwrap()),
vec![route.clone()],
));
let mut buf = BytesMut::new();
Attribute {
value: announced,
flag: AttrFlags::OPTIONAL,
}
.encode_to(AsnLength::Bits32, &mut buf)
.expect("an ADD-PATH EVPN announcement encodes");
assert!(
buf.windows(4)
.any(|window| window == [0x00, 0x00, 0x00, 0x07]),
"the path identifier is on the wire"
);
let withdrawn = AttributeValue::MpUnreachNlri(Nlri::new_evpn_unreachable(vec![route]));
let mut buf = BytesMut::new();
Attribute {
value: withdrawn,
flag: AttrFlags::OPTIONAL,
}
.encode_to(AsnLength::Bits32, &mut buf)
.expect("an ADD-PATH EVPN withdrawal encodes");
assert!(
buf.windows(4)
.any(|window| window == [0x00, 0x00, 0x00, 0x07]),
"the path identifier survives a withdrawal"
);
}
#[test]
fn truncated_evpn_nlri_is_an_error() {
let res = parse_nlri(
reach(vec![0x02, 0x08, 0, 1, 10, 10, 0, 11, 0, 2]),
&None,
&None,
&None,
true,
false,
);
assert!(res.is_err(), "a truncated route must not parse");
}
}