Merge branch 'rust-netlink:main' into netkit

Author: mccormickt

src/neighbour/attribute.rs

@@ -6,7 +6,10 @@ use netlink_packet_core::{
     ParseableParametrized,
 };
 
-use super::{NeighbourAddress, NeighbourCacheInfo, NeighbourCacheInfoBuffer};
+use super::{
+    NeighbourAddress, NeighbourCacheInfo, NeighbourCacheInfoBuffer,
+    NeighbourExtFlags,
+};
 use crate::{route::RouteProtocol, AddressFamily};
 
 const NDA_DST: u16 = 1;
@@ -24,6 +27,7 @@ const NDA_SRC_VNI: u16 = 11;
 const NDA_PROTOCOL: u16 = 12;
 // const NDA_NH_ID: u16 = 13;
 // const NDA_FDB_EXT_ATTRS: u16 = 14;
+const NDA_FLAGS_EXT: u16 = 15;
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[non_exhaustive]
@@ -40,6 +44,7 @@ pub enum NeighbourAttribute {
     LinkNetNsId(u32),
     SourceVni(u32),
     Protocol(RouteProtocol),
+    ExtFlags(NeighbourExtFlags),
     Other(DefaultNla),
 }
 
@@ -56,7 +61,8 @@ impl Nla for NeighbourAttribute {
             | Self::Controller(_)
             | Self::Vni(_)
             | Self::IfIndex(_)
-            | Self::SourceVni(_) => 4,
+            | Self::SourceVni(_)
+            | Self::ExtFlags(_) => 4,
             Self::Other(attr) => attr.value_len(),
         }
     }
@@ -76,6 +82,7 @@ impl Nla for NeighbourAttribute {
             | Self::Vni(value)
             | Self::IfIndex(value)
             | Self::SourceVni(value) => emit_u32(buffer, *value).unwrap(),
+            Self::ExtFlags(v) => emit_u32(buffer, v.bits()).unwrap(),
             Self::Protocol(v) => v.emit(buffer),
             Self::Other(attr) => attr.emit_value(buffer),
         }
@@ -95,6 +102,7 @@ impl Nla for NeighbourAttribute {
             Self::LinkNetNsId(_) => NDA_LINK_NETNSID,
             Self::SourceVni(_) => NDA_SRC_VNI,
             Self::Protocol(_) => NDA_PROTOCOL,
+            Self::ExtFlags(_) => NDA_FLAGS_EXT,
             Self::Other(nla) => nla.kind(),
         }
     }
@@ -146,6 +154,13 @@ impl<'a, T: AsRef<[u8]> + ?Sized>
                     format!("invalid NDA_PROTOCOL value {payload:?}"),
                 )?)
             }
+            NDA_FLAGS_EXT => {
+                Self::ExtFlags(NeighbourExtFlags::from_bits_retain(
+                    parse_u32(payload).context(format!(
+                        "invalid NDA_FLAGS_EXT value {payload:?}"
+                    ))?,
+                ))
+            }
             _ => Self::Other(
                 DefaultNla::parse(buf)
                     .context("invalid link NLA value (unknown type)")?,

src/neighbour/flags.rs

@@ -25,3 +25,18 @@ bitflags! {
         const _ = !0;
     }
 }
+
+const NTF_EXT_MANAGED: u32 = 1 << 0;
+const NTF_EXT_LOCKED: u32 = 1 << 1;
+const NTF_EXT_EXT_VALIDATED: u32 = 1 << 2;
+
+bitflags! {
+    #[derive(Clone, Eq, PartialEq, Debug, Copy, Default)]
+    #[non_exhaustive]
+    pub struct NeighbourExtFlags: u32 {
+        const Managed = NTF_EXT_MANAGED;
+        const Locked = NTF_EXT_LOCKED;
+        const ExtValidated = NTF_EXT_EXT_VALIDATED;
+        const _ = !0;
+    }
+}

src/neighbour/mod.rs

@@ -15,7 +15,7 @@ pub use self::{
     address::NeighbourAddress,
     attribute::NeighbourAttribute,
     cache_info::{NeighbourCacheInfo, NeighbourCacheInfoBuffer},
-    flags::NeighbourFlags,
+    flags::{NeighbourExtFlags, NeighbourFlags},
     header::{NeighbourHeader, NeighbourMessageBuffer},
     message::NeighbourMessage,
     state::NeighbourState,

src/neighbour/tests/ip.rs

@@ -10,8 +10,8 @@ use netlink_packet_core::{Emitable, Parseable};
 use crate::{
     neighbour::{
         flags::NeighbourFlags, NeighbourAttribute, NeighbourCacheInfo,
-        NeighbourHeader, NeighbourMessage, NeighbourMessageBuffer,
-        NeighbourState,
+        NeighbourExtFlags, NeighbourHeader, NeighbourMessage,
+        NeighbourMessageBuffer, NeighbourState,
     },
     route::{RouteProtocol, RouteType},
     AddressFamily,
@@ -171,3 +171,86 @@ fn test_ipv4_neighbour_protocol_show() {
 
     assert_eq!(buf, raw);
 }
+
+#[test]
+fn test_ipv4_neighbour_add_ext_flags() {
+    let raw = vec![
+        0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x08, 0x00, 0x01, 0x00, 0xac, 0x11, 0x02, 0x01, 0x08, 0x00, 0x0f, 0x00,
+        0x01, 0x00, 0x00, 0x00,
+    ];
+
+    let expected = NeighbourMessage {
+        header: NeighbourHeader {
+            family: AddressFamily::Inet,
+            ifindex: 3,
+            state: NeighbourState::None,
+            flags: NeighbourFlags::empty(),
+            kind: RouteType::Unspec,
+        },
+        attributes: vec![
+            NeighbourAttribute::Destination(
+                Ipv4Addr::from_str("172.17.2.1").unwrap().into(),
+            ),
+            NeighbourAttribute::ExtFlags(NeighbourExtFlags::Managed),
+        ],
+    };
+
+    assert_eq!(
+        expected,
+        NeighbourMessage::parse(&NeighbourMessageBuffer::new(&raw)).unwrap()
+    );
+
+    let mut buf = vec![0; expected.buffer_len()];
+
+    expected.emit(&mut buf);
+
+    assert_eq!(buf, raw);
+}
+
+#[test]
+fn test_ipv4_neighbour_show_ext_flags() {
+    let raw = vec![
+        0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01,
+        0x08, 0x00, 0x01, 0x00, 0xac, 0x11, 0x02, 0x01, 0x0a, 0x00, 0x02, 0x00,
+        0x48, 0x21, 0x0b, 0x3c, 0x1f, 0x01, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00,
+        0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x03, 0x00, 0x59, 0x02, 0x00, 0x00,
+        0x33, 0x00, 0x00, 0x00, 0xf3, 0x17, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x08, 0x00, 0x0f, 0x00, 0x01, 0x00, 0x00, 0x00,
+    ];
+
+    let expected = NeighbourMessage {
+        header: NeighbourHeader {
+            family: AddressFamily::Inet,
+            ifindex: 3,
+            state: NeighbourState::Reachable,
+            flags: NeighbourFlags::empty(),
+            kind: RouteType::Unicast,
+        },
+        attributes: vec![
+            NeighbourAttribute::Destination(
+                Ipv4Addr::from_str("172.17.2.1").unwrap().into(),
+            ),
+            NeighbourAttribute::LinkLocalAddress(vec![72, 33, 11, 60, 31, 1]),
+            NeighbourAttribute::Probes(4),
+            NeighbourAttribute::CacheInfo(NeighbourCacheInfo {
+                confirmed: 601,
+                used: 51,
+                updated: 71667,
+                refcnt: 1,
+            }),
+            NeighbourAttribute::ExtFlags(NeighbourExtFlags::Managed),
+        ],
+    };
+
+    assert_eq!(
+        expected,
+        NeighbourMessage::parse(&NeighbourMessageBuffer::new(&raw)).unwrap()
+    );
+
+    let mut buf = vec![0; expected.buffer_len()];
+
+    expected.emit(&mut buf);
+
+    assert_eq!(buf, raw);
+}