bump netlink-packet-route to 0.18.1

This was painful, a lot of big breaking chnages. However now that I have
done to work I see the benefits. The naming is much better and the API
is much more type safe.

Signed-off-by: Paul Holzinger <pholzing@redhat.com>

5 files changed, 140 insertions, 120 deletions

diff --git a/src/network/bridge.rs b/src/network/bridge.rs
index 7c0eaaa..b7f714a 100644
--- a/src/network/bridge.rs
+++ b/src/network/bridge.rs
@@ -2,9 +2,8 @@ use std::{collections::HashMap, net::IpAddr, os::fd::BorrowedFd, sync::Once};
 
 use ipnet::IpNet;
 use log::{debug, error};
-use netlink_packet_route::{
-    nlas::link::{Info, InfoData, InfoKind, Nla, VethInfo},
-    LinkMessage,
+use netlink_packet_route::link::{
+    InfoData, InfoKind, InfoVeth, LinkAttribute, LinkInfo, LinkMessage,
 };
 
 use crate::{
@@ -576,8 +575,8 @@ fn create_interfaces(
                     .wrap("get bridge interface")?;
 
                 let mut mac = None;
-                for nla in link.nlas.into_iter() {
-                    if let Nla::Address(addr) = nla {
+                for nla in link.attributes.into_iter() {
+                    if let LinkAttribute::Address(addr) = nla {
                         mac = Some(addr);
                     }
                 }
@@ -637,7 +636,7 @@ fn create_veth_pair<'fd>(
     let mut host_veth = netlink::CreateLinkOptions::new(String::from(""), InfoKind::Veth);
     host_veth.mtu = data.mtu;
     host_veth.primary_index = primary_index;
-    host_veth.info_data = Some(InfoData::Veth(VethInfo::Peer(peer)));
+    host_veth.info_data = Some(InfoData::Veth(InfoVeth::Peer(peer)));
 
     host.create_link(host_veth).map_err(|err| match err {
         NetavarkError::Netlink(ref e) if -e.raw_code() == libc::EEXIST => NetavarkError::wrap(
@@ -659,11 +658,11 @@ fn create_veth_pair<'fd>(
     let mut mac = String::from("");
     let mut host_link = 0;
 
-    for nla in veth.nlas.into_iter() {
-        if let Nla::Address(ref addr) = nla {
+    for nla in veth.attributes.into_iter() {
+        if let LinkAttribute::Address(ref addr) = nla {
             mac = CoreUtils::encode_address_to_hex(addr);
         }
-        if let Nla::Link(link) = nla {
+        if let LinkAttribute::Link(link) = nla {
             host_link = link;
         }
     }
@@ -697,8 +696,8 @@ fn create_veth_pair<'fd>(
     if data.ipam.ipv6_enabled {
         let host_veth = host.get_link(netlink::LinkID::ID(host_link))?;
 
-        for nla in host_veth.nlas.into_iter() {
-            if let Nla::IfName(name) = nla {
+        for nla in host_veth.attributes.into_iter() {
+            if let LinkAttribute::IfName(name) = nla {
                 //  Disable dad inside on the host too
                 let disable_dad_in_container = format!("/proc/sys/net/ipv6/conf/{name}/accept_dad");
                 core_utils::CoreUtils::apply_sysctl_value(disable_dad_in_container, "0")?;
@@ -747,10 +746,10 @@ fn create_veth_pair<'fd>(
 
 /// make sure the LinkMessage has the kind bridge
 fn check_link_is_bridge(msg: LinkMessage, br_name: &str) -> NetavarkResult<LinkMessage> {
-    for nla in msg.nlas.iter() {
-        if let Nla::Info(info) = nla {
+    for nla in msg.attributes.iter() {
+        if let LinkAttribute::LinkInfo(info) = nla {
             for inf in info.iter() {
-                if let Info::Kind(kind) = inf {
+                if let LinkInfo::Kind(kind) = inf {
                     if *kind == InfoKind::Bridge {
                         return Ok(msg);
                     } else {
@@ -769,10 +768,10 @@ fn check_link_is_bridge(msg: LinkMessage, br_name: &str) -> NetavarkResult<LinkM
 
 /// make sure the LinkMessage is the kind VRF
 fn check_link_is_vrf(msg: LinkMessage, vrf_name: &str) -> NetavarkResult<LinkMessage> {
-    for nla in msg.nlas.iter() {
-        if let Nla::Info(info) = nla {
+    for nla in msg.attributes.iter() {
+        if let LinkAttribute::LinkInfo(info) = nla {
             for inf in info.iter() {
-                if let Info::Kind(kind) = inf {
+                if let LinkInfo::Kind(kind) = inf {
                     if *kind == InfoKind::Vrf {
                         return Ok(msg);
                     } else {
@@ -808,7 +807,7 @@ fn remove_link(
         .wrap("failed to get bridge interface")?;
 
     let links = host
-        .dump_links(&mut vec![Nla::Master(br.header.index)])
+        .dump_links(&mut vec![LinkAttribute::Controller(br.header.index)])
         .wrap("failed to get connected bridge interfaces")?;
     // no connected interfaces on that bridge we can remove it
     if links.is_empty() {
diff --git a/src/network/core_utils.rs b/src/network/core_utils.rs
index 0b06780..8638f98 100644
--- a/src/network/core_utils.rs
+++ b/src/network/core_utils.rs
@@ -3,10 +3,6 @@ use crate::network::{constants, internal_types, types};
 use crate::wrap;
 use ipnet::IpNet;
 use log::debug;
-use netlink_packet_route::{
-    MACVLAN_MODE_BRIDGE, MACVLAN_MODE_PASSTHRU, MACVLAN_MODE_PRIVATE, MACVLAN_MODE_SOURCE,
-    MACVLAN_MODE_VEPA,
-};
 use nix::sched;
 use sha2::{Digest, Sha512};
 use std::collections::HashMap;
@@ -27,6 +23,14 @@ pub const IPVLAN_MODE_L2: u16 = 0;
 pub const IPVLAN_MODE_L3: u16 = 1;
 pub const IPVLAN_MODE_L3S: u16 = 2;
 
+// const were removed upstream:
+// https://github.com/rust-netlink/netlink-packet-route/issues/88
+pub const MACVLAN_MODE_PRIVATE: u32 = 1;
+pub const MACVLAN_MODE_VEPA: u32 = 2;
+pub const MACVLAN_MODE_BRIDGE: u32 = 4;
+pub const MACVLAN_MODE_PASSTHRU: u32 = 8;
+pub const MACVLAN_MODE_SOURCE: u32 = 16;
+
 pub struct CoreUtils {
     pub networkns: String,
 }
diff --git a/src/network/netlink.rs b/src/network/netlink.rs
index c1d9dfd..c95a67b 100644
--- a/src/network/netlink.rs
+++ b/src/network/netlink.rs
@@ -14,9 +14,11 @@ use netlink_packet_core::{
     NLM_F_REQUEST,
 };
 use netlink_packet_route::{
-    nlas::link::{Info, InfoData, InfoKind, Nla},
-    AddressMessage, LinkMessage, RouteMessage, RtnlMessage, AF_INET, AF_INET6, IFF_UP, RTN_UNICAST,
-    RTPROT_STATIC, RTPROT_UNSPEC, RT_SCOPE_UNIVERSE, RT_TABLE_MAIN,
+    address::AddressMessage,
+    link::{InfoData, InfoKind, LinkAttribute, LinkInfo},
+    link::{LinkFlag, LinkMessage},
+    route::{RouteAddress, RouteMessage, RouteProtocol, RouteScope, RouteType},
+    AddressFamily, RouteNetlinkMessage,
 };
 use netlink_sys::{protocols::NETLINK_ROUTE, SocketAddr};
 
@@ -125,13 +127,13 @@ impl Socket {
 
         match id {
             LinkID::ID(id) => msg.header.index = id,
-            LinkID::Name(name) => msg.nlas.push(Nla::IfName(name)),
+            LinkID::Name(name) => msg.attributes.push(LinkAttribute::IfName(name)),
         }
 
-        let mut result = self.make_netlink_request(RtnlMessage::GetLink(msg), 0)?;
+        let mut result = self.make_netlink_request(RouteNetlinkMessage::GetLink(msg), 0)?;
         expect_netlink_result!(result, 1);
         match result.remove(0) {
-            RtnlMessage::NewLink(m) => Ok(m),
+            RouteNetlinkMessage::NewLink(m) => Ok(m),
             m => Err(NetavarkError::Message(format!(
                 "unexpected netlink message type: {}",
                 m.message_type()
@@ -143,7 +145,7 @@ impl Socket {
         let mut msg = LinkMessage::default();
         parse_create_link_options(&mut msg, options);
         let result = self.make_netlink_request(
-            RtnlMessage::NewLink(msg),
+            RouteNetlinkMessage::NewLink(msg),
             NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE,
         )?;
         expect_netlink_result!(result, 0);
@@ -154,8 +156,8 @@ impl Socket {
     pub fn set_link_name(&mut self, id: u32, name: String) -> NetavarkResult<()> {
         let mut msg = LinkMessage::default();
         msg.header.index = id;
-        msg.nlas.push(Nla::IfName(name));
-        let result = self.make_netlink_request(RtnlMessage::SetLink(msg), NLM_F_ACK)?;
+        msg.attributes.push(LinkAttribute::IfName(name));
+        let result = self.make_netlink_request(RouteNetlinkMessage::SetLink(msg), NLM_F_ACK)?;
         expect_netlink_result!(result, 0);
 
         Ok(())
@@ -166,10 +168,10 @@ impl Socket {
 
         match id {
             LinkID::ID(id) => msg.header.index = id,
-            LinkID::Name(name) => msg.nlas.push(Nla::IfName(name)),
+            LinkID::Name(name) => msg.attributes.push(LinkAttribute::IfName(name)),
         }
 
-        let result = self.make_netlink_request(RtnlMessage::DelLink(msg), NLM_F_ACK)?;
+        let result = self.make_netlink_request(RouteNetlinkMessage::DelLink(msg), NLM_F_ACK)?;
         expect_netlink_result!(result, 0);
         Ok(())
     }
@@ -177,9 +179,10 @@ impl Socket {
     pub fn set_link_ns<Fd: AsFd>(&mut self, link_id: u32, netns: Fd) -> NetavarkResult<()> {
         let mut msg = LinkMessage::default();
         msg.header.index = link_id;
-        msg.nlas.push(Nla::NetNsFd(netns.as_fd().as_raw_fd()));
+        msg.attributes
+            .push(LinkAttribute::NetNsFd(netns.as_fd().as_raw_fd()));
 
-        let result = self.make_netlink_request(RtnlMessage::SetLink(msg), NLM_F_ACK)?;
+        let result = self.make_netlink_request(RouteNetlinkMessage::SetLink(msg), NLM_F_ACK)?;
         expect_netlink_result!(result, 0);
         Ok(())
     }
@@ -188,30 +191,31 @@ impl Socket {
         let mut msg = AddressMessage::default();
         msg.header.index = link_id;
 
-        let addr_vec = match addr {
+        match addr {
             ipnet::IpNet::V4(v4) => {
-                msg.header.family = AF_INET as u8;
-                msg.nlas.push(netlink_packet_route::address::Nla::Broadcast(
-                    v4.broadcast().octets().to_vec(),
-                ));
-                v4.addr().octets().to_vec()
+                msg.header.family = AddressFamily::Inet;
+                msg.attributes
+                    .push(netlink_packet_route::address::AddressAttribute::Broadcast(
+                        v4.broadcast(),
+                    ));
             }
-            ipnet::IpNet::V6(v6) => {
-                msg.header.family = AF_INET6 as u8;
-                v6.addr().octets().to_vec()
+            ipnet::IpNet::V6(_) => {
+                msg.header.family = AddressFamily::Inet6;
             }
         };
 
         msg.header.prefix_len = addr.prefix_len();
-        msg.nlas
-            .push(netlink_packet_route::address::Nla::Local(addr_vec));
+        msg.attributes
+            .push(netlink_packet_route::address::AddressAttribute::Local(
+                addr.addr(),
+            ));
         msg
     }
 
     pub fn add_addr(&mut self, link_id: u32, addr: &ipnet::IpNet) -> NetavarkResult<()> {
         let msg = Self::create_addr_msg(link_id, addr);
         let result = match self.make_netlink_request(
-            RtnlMessage::NewAddress(msg),
+            RouteNetlinkMessage::NewAddress(msg),
             NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE,
         ) {
             Ok(result) => result,
@@ -236,7 +240,7 @@ impl Socket {
 
     pub fn del_addr(&mut self, link_id: u32, addr: &ipnet::IpNet) -> NetavarkResult<()> {
         let msg = Self::create_addr_msg(link_id, addr);
-        let result = self.make_netlink_request(RtnlMessage::DelAddress(msg), NLM_F_ACK)?;
+        let result = self.make_netlink_request(RouteNetlinkMessage::DelAddress(msg), NLM_F_ACK)?;
         expect_netlink_result!(result, 0);
 
         Ok(())
@@ -245,39 +249,45 @@ impl Socket {
     fn create_route_msg(route: &Route) -> RouteMessage {
         let mut msg = RouteMessage::default();
 
-        msg.header.table = RT_TABLE_MAIN;
-        msg.header.protocol = RTPROT_STATIC;
-        msg.header.scope = RT_SCOPE_UNIVERSE;
-        msg.header.kind = RTN_UNICAST;
+        msg.header.table = libc::RT_TABLE_MAIN;
+        msg.header.protocol = RouteProtocol::Static;
+        msg.header.scope = RouteScope::Universe;
+        msg.header.kind = RouteType::Unicast;
 
-        let (dest_vec, dest_prefix, gateway_vec, final_metric) = match route {
+        let (dest, dest_prefix, gateway, final_metric) = match route {
             Route::Ipv4 { dest, gw, metric } => {
-                msg.header.address_family = AF_INET as u8;
+                msg.header.address_family = AddressFamily::Inet;
                 (
-                    dest.addr().octets().to_vec(),
+                    RouteAddress::Inet(dest.addr()),
                     dest.prefix_len(),
-                    gw.octets().to_vec(),
+                    RouteAddress::Inet(*gw),
                     metric.unwrap_or(constants::DEFAULT_METRIC),
                 )
             }
             Route::Ipv6 { dest, gw, metric } => {
-                msg.header.address_family = AF_INET6 as u8;
+                msg.header.address_family = AddressFamily::Inet6;
                 (
-                    dest.addr().octets().to_vec(),
+                    RouteAddress::Inet6(dest.addr()),
                     dest.prefix_len(),
-                    gw.octets().to_vec(),
+                    RouteAddress::Inet6(*gw),
                     metric.unwrap_or(constants::DEFAULT_METRIC),
                 )
             }
         };
 
         msg.header.destination_prefix_length = dest_prefix;
-        msg.nlas
-            .push(netlink_packet_route::route::Nla::Destination(dest_vec));
-        msg.nlas
-            .push(netlink_packet_route::route::Nla::Gateway(gateway_vec));
-        msg.nlas
-            .push(netlink_packet_route::route::Nla::Priority(final_metric));
+        msg.attributes
+            .push(netlink_packet_route::route::RouteAttribute::Destination(
+                dest,
+            ));
+        msg.attributes
+            .push(netlink_packet_route::route::RouteAttribute::Gateway(
+                gateway,
+            ));
+        msg.attributes
+            .push(netlink_packet_route::route::RouteAttribute::Priority(
+                final_metric,
+            ));
         msg
     }
 
@@ -285,8 +295,8 @@ impl Socket {
         let msg = Self::create_route_msg(route);
         info!("Adding route {}", route);
 
-        let result =
-            self.make_netlink_request(RtnlMessage::NewRoute(msg), NLM_F_ACK | NLM_F_CREATE)?;
+        let result = self
+            .make_netlink_request(RouteNetlinkMessage::NewRoute(msg), NLM_F_ACK | NLM_F_CREATE)?;
         expect_netlink_result!(result, 0);
 
         Ok(())
@@ -296,7 +306,7 @@ impl Socket {
         let msg = Self::create_route_msg(route);
         info!("Deleting route {}", route);
 
-        let result = self.make_netlink_request(RtnlMessage::DelRoute(msg), NLM_F_ACK)?;
+        let result = self.make_netlink_request(RouteNetlinkMessage::DelRoute(msg), NLM_F_ACK)?;
         expect_netlink_result!(result, 0);
 
         Ok(())
@@ -305,19 +315,19 @@ impl Socket {
     pub fn dump_routes(&mut self) -> NetavarkResult<Vec<RouteMessage>> {
         let mut msg = RouteMessage::default();
 
-        msg.header.table = RT_TABLE_MAIN;
-        msg.header.protocol = RTPROT_UNSPEC;
-        msg.header.scope = RT_SCOPE_UNIVERSE;
-        msg.header.kind = RTN_UNICAST;
+        msg.header.table = libc::RT_TABLE_MAIN;
+        msg.header.protocol = RouteProtocol::Unspec;
+        msg.header.scope = RouteScope::Universe;
+        msg.header.kind = RouteType::Unicast;
 
         let results =
-            self.make_netlink_request(RtnlMessage::GetRoute(msg), NLM_F_DUMP | NLM_F_ACK)?;
+            self.make_netlink_request(RouteNetlinkMessage::GetRoute(msg), NLM_F_DUMP | NLM_F_ACK)?;
 
         let mut routes = Vec::with_capacity(results.len());
 
         for res in results {
             match res {
-                RtnlMessage::NewRoute(m) => routes.push(m),
+                RouteNetlinkMessage::NewRoute(m) => routes.push(m),
                 m => {
                     return Err(NetavarkError::Message(format!(
                         "unexpected netlink message type: {}",
@@ -329,18 +339,21 @@ impl Socket {
         Ok(routes)
     }
 
-    pub fn dump_links(&mut self, nlas: &mut Vec<Nla>) -> NetavarkResult<Vec<LinkMessage>> {
+    pub fn dump_links(
+        &mut self,
+        nlas: &mut Vec<LinkAttribute>,
+    ) -> NetavarkResult<Vec<LinkMessage>> {
         let mut msg = LinkMessage::default();
-        msg.nlas.append(nlas);
+        msg.attributes.append(nlas);
 
         let results =
-            self.make_netlink_request(RtnlMessage::GetLink(msg), NLM_F_DUMP | NLM_F_ACK)?;
+            self.make_netlink_request(RouteNetlinkMessage::GetLink(msg), NLM_F_DUMP | NLM_F_ACK)?;
 
         let mut links = Vec::with_capacity(results.len());
 
         for res in results {
             match res {
-                RtnlMessage::NewLink(m) => links.push(m),
+                RouteNetlinkMessage::NewLink(m) => links.push(m),
                 m => {
                     return Err(NetavarkError::Message(format!(
                         "unexpected netlink message type: {}",
@@ -355,14 +368,14 @@ impl Socket {
     pub fn dump_addresses(&mut self) -> NetavarkResult<Vec<AddressMessage>> {
         let msg = AddressMessage::default();
 
-        let results =
-            self.make_netlink_request(RtnlMessage::GetAddress(msg), NLM_F_DUMP | NLM_F_ACK)?;
+        let results = self
+            .make_netlink_request(RouteNetlinkMessage::GetAddress(msg), NLM_F_DUMP | NLM_F_ACK)?;
 
         let mut addresses = Vec::with_capacity(results.len());
 
         for res in results {
             match res {
-                RtnlMessage::NewAddress(m) => addresses.push(m),
+                RouteNetlinkMessage::NewAddress(m) => addresses.push(m),
                 m => {
                     return Err(NetavarkError::Message(format!(
                         "unexpected netlink message type: {}",
@@ -379,14 +392,14 @@ impl Socket {
 
         match id {
             LinkID::ID(id) => msg.header.index = id,
-            LinkID::Name(name) => msg.nlas.push(Nla::IfName(name)),
+            LinkID::Name(name) => msg.attributes.push(LinkAttribute::IfName(name)),
         }
 
-        msg.header.flags |= IFF_UP;
-        msg.header.change_mask |= IFF_UP;
+        msg.header.flags = vec![LinkFlag::Up];
+        msg.header.change_mask = vec![LinkFlag::Up];
 
         let result = self.make_netlink_request(
-            RtnlMessage::SetLink(msg),
+            RouteNetlinkMessage::SetLink(msg),
             NLM_F_ACK | NLM_F_EXCL | NLM_F_CREATE,
         )?;
         expect_netlink_result!(result, 0);
@@ -399,12 +412,12 @@ impl Socket {
 
         match id {
             LinkID::ID(id) => msg.header.index = id,
-            LinkID::Name(name) => msg.nlas.push(Nla::IfName(name)),
+            LinkID::Name(name) => msg.attributes.push(LinkAttribute::IfName(name)),
         }
 
-        msg.nlas.push(Nla::Address(mac));
+        msg.attributes.push(LinkAttribute::Address(mac));
 
-        let result = self.make_netlink_request(RtnlMessage::SetLink(msg), NLM_F_ACK)?;
+        let result = self.make_netlink_request(RouteNetlinkMessage::SetLink(msg), NLM_F_ACK)?;
         expect_netlink_result!(result, 0);
 
         Ok(())
@@ -412,14 +425,14 @@ impl Socket {
 
     fn make_netlink_request(
         &mut self,
-        msg: RtnlMessage,
+        msg: RouteNetlinkMessage,
         flags: u16,
-    ) -> NetavarkResult<Vec<RtnlMessage>> {
+    ) -> NetavarkResult<Vec<RouteNetlinkMessage>> {
         self.send(msg, flags).wrap("send to netlink")?;
         self.recv(flags & NLM_F_DUMP == NLM_F_DUMP)
     }
 
-    fn send(&mut self, msg: RtnlMessage, flags: u16) -> NetavarkResult<()> {
+    fn send(&mut self, msg: RouteNetlinkMessage, flags: u16) -> NetavarkResult<()> {
         let mut packet = NetlinkMessage::new(NetlinkHeader::default(), NetlinkPayload::from(msg));
         packet.header.flags = NLM_F_REQUEST | flags;
         packet.header.sequence_number = {
@@ -435,7 +448,7 @@ impl Socket {
         Ok(())
     }
 
-    fn recv(&mut self, multi: bool) -> NetavarkResult<Vec<RtnlMessage>> {
+    fn recv(&mut self, multi: bool) -> NetavarkResult<Vec<RouteNetlinkMessage>> {
         let mut offset = 0;
         let mut result = Vec::new();
 
@@ -448,8 +461,8 @@ impl Socket {
 
             loop {
                 let bytes = &self.buffer[offset..];
-                let rx_packet: NetlinkMessage<RtnlMessage> = NetlinkMessage::deserialize(bytes)
-                    .map_err(|e| {
+                let rx_packet: NetlinkMessage<RouteNetlinkMessage> =
+                    NetlinkMessage::deserialize(bytes).map_err(|e| {
                         NetavarkError::Message(format!(
                             "failed to deserialize netlink message: {e}",
                         ))
@@ -517,39 +530,41 @@ impl CreateLinkOptions<'_> {
 
 pub fn parse_create_link_options(msg: &mut LinkMessage, options: CreateLinkOptions) {
     // add link specific data
-    let mut link_info_nlas = vec![Info::Kind(options.kind)];
+    let mut link_info_nlas = vec![LinkInfo::Kind(options.kind)];
     if let Some(data) = options.info_data {
-        link_info_nlas.push(Info::Data(data));
+        link_info_nlas.push(LinkInfo::Data(data));
     }
-    msg.nlas.push(Nla::Info(link_info_nlas));
+    msg.attributes.push(LinkAttribute::LinkInfo(link_info_nlas));
 
     // add name
     if !options.name.is_empty() {
-        msg.nlas.push(Nla::IfName(options.name));
+        msg.attributes.push(LinkAttribute::IfName(options.name));
     }
 
     // add mtu
     if options.mtu != 0 {
-        msg.nlas.push(Nla::Mtu(options.mtu));
+        msg.attributes.push(LinkAttribute::Mtu(options.mtu));
     }
 
     // add mac address
     if !options.mac.is_empty() {
-        msg.nlas.push(Nla::Address(options.mac));
+        msg.attributes.push(LinkAttribute::Address(options.mac));
     }
 
     // add primary device
     if options.primary_index != 0 {
-        msg.nlas.push(Nla::Master(options.primary_index));
+        msg.attributes
+            .push(LinkAttribute::Controller(options.primary_index));
     }
 
     // add link device
     if options.link != 0 {
-        msg.nlas.push(Nla::Link(options.link));
+        msg.attributes.push(LinkAttribute::Link(options.link));
     }
 
     // add netnsfd
     if let Some(netns) = options.netns {
-        msg.nlas.push(Nla::NetNsFd(netns.as_raw_fd()));
+        msg.attributes
+            .push(LinkAttribute::NetNsFd(netns.as_raw_fd()));
     }
 }
diff --git a/src/network/vlan.rs b/src/network/vlan.rs
index 95035eb..83e84c2 100644
--- a/src/network/vlan.rs
+++ b/src/network/vlan.rs
@@ -2,7 +2,7 @@ use log::{debug, error};
 use std::os::fd::BorrowedFd;
 use std::{collections::HashMap, net::IpAddr};
 
-use netlink_packet_route::nlas::link::{InfoData, InfoIpVlan, InfoKind, InfoMacVlan, Nla};
+use netlink_packet_route::link::{InfoData, InfoIpVlan, InfoKind, InfoMacVlan, LinkAttribute};
 use rand::distributions::{Alphanumeric, DistString};
 
 use crate::network::macvlan_dhcp::{get_dhcp_lease, release_dhcp_lease};
@@ -220,7 +220,7 @@ impl driver::NetworkDriver for Vlan<'_> {
                     &self.info.per_network_opts.interface_name
                 ))?;
 
-            let container_mac_address = get_mac_address(dev.nlas)?;
+            let container_mac_address = get_mac_address(dev.attributes)?;
             release_dhcp_lease(
                 &self
                     .info
@@ -373,12 +373,12 @@ fn setup(
         netns.add_route(route)?
     }
 
-    get_mac_address(dev.nlas)
+    get_mac_address(dev.attributes)
 }
 
-fn get_mac_address(v: Vec<Nla>) -> NetavarkResult<String> {
+fn get_mac_address(v: Vec<LinkAttribute>) -> NetavarkResult<String> {
     for nla in v.into_iter() {
-        if let Nla::Address(ref addr) = nla {
+        if let LinkAttribute::Address(ref addr) = nla {
             return Ok(CoreUtils::encode_address_to_hex(addr));
         }
     }
@@ -393,11 +393,11 @@ fn get_default_route_interface(host: &mut netlink::Socket) -> NetavarkResult<Str
     for route in routes {
         let mut dest = false;
         let mut out_if = 0;
-        for nla in route.nlas {
-            if let netlink_packet_route::route::Nla::Destination(_) = nla {
+        for nla in route.attributes {
+            if let netlink_packet_route::route::RouteAttribute::Destination(_) = nla {
                 dest = true;
             }
-            if let netlink_packet_route::route::Nla::Oif(oif) = nla {
+            if let netlink_packet_route::route::RouteAttribute::Oif(oif) = nla {
                 out_if = oif;
             }
         }
@@ -406,8 +406,8 @@ fn get_default_route_interface(host: &mut netlink::Socket) -> NetavarkResult<Str
         // return the output interface for this route
         if !dest && out_if > 0 {
             let link = host.get_link(netlink::LinkID::ID(out_if))?;
-            let name = link.nlas.iter().find_map(|nla| {
-                if let Nla::IfName(name) = nla {
+            let name = link.attributes.iter().find_map(|nla| {
+                if let LinkAttribute::IfName(name) = nla {
                     Some(name)
                 } else {
                     None
diff --git a/src/test/netlink.rs b/src/test/netlink.rs
index c0ec764..6b7eb65 100644
--- a/src/test/netlink.rs
+++ b/src/test/netlink.rs
@@ -1,7 +1,9 @@
 #[cfg(test)]
 mod tests {
+    use std::net::{IpAddr, Ipv4Addr};
+
     use netavark::network::netlink::*;
-    use netlink_packet_route::{address, nlas::link::InfoKind};
+    use netlink_packet_route::{address, link::InfoKind};
 
     macro_rules! test_setup {
         () => {
@@ -174,14 +176,14 @@ mod tests {
         assert!(out.status.success(), "failed to set up lo via ip");
 
         let addresses = sock.dump_addresses().expect("dump_addresses failed");
-        for nla in addresses[0].nlas.iter() {
-            if let address::Nla::Address(a) = nla {
-                assert_eq!(a, &vec![127, 0, 0, 1])
+        for nla in addresses[0].attributes.iter() {
+            if let address::AddressAttribute::Address(ip) = nla {
+                assert_eq!(ip, &IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)))
             }
         }
-        for nla in addresses[1].nlas.iter() {
-            if let address::Nla::Address(a) = nla {
-                assert_eq!(a, &vec![10, 0, 0, 2])
+        for nla in addresses[1].attributes.iter() {
+            if let address::AddressAttribute::Address(ip) = nla {
+                assert_eq!(ip, &IpAddr::V4(Ipv4Addr::new(10, 0, 0, 2)))
             }
         }
     }