diff --git a/src/ethernet_interface.cpp b/src/ethernet_interface.cpp
index 8700d05..a1d9b83 100644
--- a/src/ethernet_interface.cpp
+++ b/src/ethernet_interface.cpp
@@ -3,8 +3,10 @@
 #include "ethernet_interface.hpp"
 
 #include "config_parser.hpp"
+#include "ipaddress.hpp"
 #include "neighbor.hpp"
 #include "network_manager.hpp"
+#include "types.hpp"
 #include "vlan_interface.hpp"
 
 #include <arpa/inet.h>
@@ -125,17 +127,18 @@
     }
 }
 
-static IP::Protocol convertFamily(int family)
+static IP::Protocol getProtocol(const InAddrAny& addr)
 {
-    switch (family)
+    if (std::holds_alternative<in_addr>(addr))
     {
-        case AF_INET:
-            return IP::Protocol::IPv4;
-        case AF_INET6:
-            return IP::Protocol::IPv6;
+        return IP::Protocol::IPv4;
+    }
+    else if (std::holds_alternative<in6_addr>(addr))
+    {
+        return IP::Protocol::IPv6;
     }
 
-    throw std::invalid_argument("Bad address family");
+    throw std::runtime_error("Invalid addr type");
 }
 
 void EthernetInterface::disableDHCP(IP::Protocol protocol)
@@ -191,17 +194,19 @@
 {
     addrs.clear();
 
-    auto addrs = getInterfaceAddrs()[interfaceName()];
-
-    for (auto& addr : addrs)
+    AddressFilter filter;
+    filter.interface = ifIndex();
+    auto currentAddrs = getCurrentAddresses(filter);
+    for (const auto& addr : currentAddrs)
     {
-        IP::Protocol addressType = convertFamily(addr.addrType);
+        auto address = toString(addr.address);
+        IP::Protocol addressType = getProtocol(addr.address);
         IP::AddressOrigin origin = IP::AddressOrigin::Static;
         if (dhcpIsEnabled(addressType))
         {
             origin = IP::AddressOrigin::DHCP;
         }
-        if (isLinkLocalIP(addr.ipaddress))
+        if (addr.scope == RT_SCOPE_LINK)
         {
             origin = IP::AddressOrigin::LinkLocal;
         }
@@ -209,13 +214,12 @@
         std::string gateway = "";
 
         std::string ipAddressObjectPath = generateObjectPath(
-            addressType, addr.ipaddress, addr.prefix, gateway, origin);
+            addressType, address, addr.prefix, gateway, origin);
 
         this->addrs.insert_or_assign(
-            addr.ipaddress,
-            std::make_shared<phosphor::network::IPAddress>(
-                bus, ipAddressObjectPath.c_str(), *this, addressType,
-                addr.ipaddress, origin, addr.prefix, gateway));
+            address, std::make_shared<phosphor::network::IPAddress>(
+                         bus, ipAddressObjectPath.c_str(), *this, addressType,
+                         address, origin, addr.prefix, gateway));
     }
 }
 
diff --git a/src/ipaddress.cpp b/src/ipaddress.cpp
index ee87d6c..becb5b3 100644
--- a/src/ipaddress.cpp
+++ b/src/ipaddress.cpp
@@ -3,16 +3,38 @@
 #include "ipaddress.hpp"
 
 #include "ethernet_interface.hpp"
+#include "netlink.hpp"
 #include "util.hpp"
 
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
 #include <phosphor-logging/elog-errors.hpp>
 #include <phosphor-logging/log.hpp>
+#include <stdexcept>
+#include <stdplus/raw.hpp>
+#include <string>
+#include <string_view>
+#include <vector>
 #include <xyz/openbmc_project/Common/error.hpp>
+
 namespace phosphor
 {
 namespace network
 {
 
+std::vector<AddressInfo> getCurrentAddresses(const AddressFilter& filter)
+{
+    std::vector<AddressInfo> addresses;
+    auto cb = [&filter, &addresses](const nlmsghdr& hdr, std::string_view msg) {
+        detail::parseAddress(filter, hdr, msg, addresses);
+    };
+    ifaddrmsg msg{};
+    msg.ifa_index = filter.interface;
+    netlink::performRequest(NETLINK_ROUTE, RTM_GETADDR, NLM_F_DUMP, msg, cb);
+    return addresses;
+}
+
 using namespace phosphor::logging;
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
 using NotAllowed = sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed;
@@ -69,5 +91,56 @@
     parent.deleteObject(address());
 }
 
+namespace detail
+{
+
+void parseAddress(const AddressFilter& filter, const nlmsghdr& hdr,
+                  std::string_view msg, std::vector<AddressInfo>& addresses)
+{
+    if (hdr.nlmsg_type != RTM_NEWADDR)
+    {
+        throw std::runtime_error("Not an address msg");
+    }
+    auto ifaddr = stdplus::raw::extract<ifaddrmsg>(msg);
+
+    // Filter out addresses we don't care about
+    unsigned ifindex = ifaddr.ifa_index;
+    if (filter.interface != 0 && filter.interface != ifindex)
+    {
+        return;
+    }
+    if (filter.scope && *filter.scope != ifaddr.ifa_scope)
+    {
+        return;
+    }
+
+    // Build the info about the address we found
+    AddressInfo address;
+    address.interface = ifindex;
+    address.prefix = ifaddr.ifa_prefixlen;
+    address.flags = ifaddr.ifa_flags;
+    address.scope = ifaddr.ifa_scope;
+    bool set_addr = false;
+    while (!msg.empty())
+    {
+        auto [hdr, data] = netlink::extractRtAttr(msg);
+        if (hdr.rta_type == IFA_ADDRESS)
+        {
+            address.address = addrFromBuf(ifaddr.ifa_family, data);
+            set_addr = true;
+        }
+        else if (hdr.rta_type == IFA_FLAGS)
+        {
+            address.flags = stdplus::raw::extract<uint32_t>(data);
+        }
+    }
+    if (!set_addr)
+    {
+        throw std::runtime_error("Missing address");
+    }
+    addresses.push_back(std::move(address));
+}
+
+} // namespace detail
 } // namespace network
 } // namespace phosphor
diff --git a/src/ipaddress.hpp b/src/ipaddress.hpp
index b78b677..b46d64e 100644
--- a/src/ipaddress.hpp
+++ b/src/ipaddress.hpp
@@ -1,8 +1,15 @@
 #pragma once
+#include "types.hpp"
 
+#include <linux/netlink.h>
+
+#include <cstdint>
+#include <optional>
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/object.hpp>
 #include <string>
+#include <string_view>
+#include <vector>
 #include <xyz/openbmc_project/Network/IP/server.hpp>
 #include <xyz/openbmc_project/Object/Delete/server.hpp>
 
@@ -19,6 +26,30 @@
 
 class EthernetInterface;
 
+/* @class AddressFilter
+ */
+struct AddressFilter
+{
+    unsigned interface = 0;
+    std::optional<uint8_t> scope;
+};
+
+/** @class AddressInfo
+ *  @brief Information about a addresses from the kernel
+ */
+struct AddressInfo
+{
+    unsigned interface;
+    InAddrAny address;
+    uint8_t prefix;
+    uint8_t scope;
+    uint32_t flags;
+};
+
+/** @brief Returns a list of the current system neighbor table
+ */
+std::vector<AddressInfo> getCurrentAddresses(const AddressFilter& filter);
+
 /** @class IPAddress
  *  @brief OpenBMC IPAddress implementation.
  *  @details A concrete implementation for the
@@ -71,5 +102,12 @@
     EthernetInterface& parent;
 };
 
+namespace detail
+{
+
+void parseAddress(const AddressFilter& filter, const nlmsghdr& hdr,
+                  std::string_view msg, std::vector<AddressInfo>& addresses);
+
+} // namespace detail
 } // namespace network
 } // namespace phosphor
diff --git a/src/types.hpp b/src/types.hpp
index a4173c1..2e27298 100644
--- a/src/types.hpp
+++ b/src/types.hpp
@@ -1,24 +1,18 @@
 #pragma once
 
-#include "ipaddress.hpp"
-
 #include <ifaddrs.h>
 #include <netinet/in.h>
 #include <systemd/sd-event.h>
 
-#include <array>
 #include <chrono>
 #include <cstddef>
 #include <functional>
-#include <list>
-#include <map>
 #include <memory>
 #include <sdeventplus/clock.hpp>
 #include <sdeventplus/utility/timer.hpp>
 #include <set>
 #include <string>
 #include <variant>
-#include <vector>
 
 namespace phosphor
 {
@@ -48,13 +42,6 @@
 
 using IntfName = std::string;
 
-struct AddrInfo
-{
-    uint8_t addrType;
-    std::string ipaddress;
-    uint16_t prefix;
-};
-
 using Addr_t = ifaddrs*;
 
 struct AddrDeleter
@@ -83,8 +70,6 @@
 // Byte representations for common address types in network byte order
 using InAddrAny = std::variant<struct in_addr, struct in6_addr>;
 
-using AddrList = std::list<AddrInfo>;
-using IntfAddrMap = std::map<IntfName, AddrList>;
 using InterfaceList = std::set<IntfName>;
 
 using Timer = sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>;
diff --git a/src/util.cpp b/src/util.cpp
index 3bd3806..803d26e 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -145,43 +145,6 @@
 
 } // namespace internal
 
-uint8_t toCidr(int addressFamily, const std::string& subnetMask)
-{
-    uint32_t subnet[sizeof(in6_addr) / sizeof(uint32_t)];
-    if (inet_pton(addressFamily, subnetMask.c_str(), &subnet) != 1)
-    {
-        log<level::ERR>("inet_pton failed:",
-                        entry("SUBNETMASK=%s", subnetMask.c_str()));
-        return 0;
-    }
-
-    static_assert(sizeof(in6_addr) % sizeof(uint32_t) == 0);
-    static_assert(sizeof(in_addr) % sizeof(uint32_t) == 0);
-    auto i = (addressFamily == AF_INET ? sizeof(in_addr) : sizeof(in6_addr)) /
-             sizeof(uint32_t);
-    while (i > 0)
-    {
-        if (subnet[--i] != 0)
-        {
-            auto v = be32toh(subnet[i]);
-            static_assert(sizeof(unsigned) == sizeof(uint32_t));
-            auto trailing = __builtin_ctz(v);
-            auto ret = (i + 1) * 32 - trailing;
-            bool valid = ~v == 0 || 32 == trailing + __builtin_clz(~v);
-            while (i > 0 && (valid = (~subnet[--i] == 0) && valid))
-                ;
-            if (!valid)
-            {
-                log<level::ERR>("Invalid netmask",
-                                entry("SUBNETMASK=%s", subnetMask.c_str()));
-                return 0;
-            }
-            return ret;
-        }
-    }
-    return 0;
-}
-
 std::string toMask(int addressFamily, uint8_t prefix)
 {
     if (addressFamily == AF_INET6)
@@ -272,11 +235,6 @@
     throw std::runtime_error("Invalid addr type");
 }
 
-bool isLinkLocalIP(const std::string& address)
-{
-    return address.find(IPV4_PREFIX) == 0 || address.find(IPV6_PREFIX) == 0;
-}
-
 bool isValidIP(int addressFamily, const std::string& address)
 {
     unsigned char buf[sizeof(struct in6_addr)];
@@ -307,81 +265,6 @@
     return true;
 }
 
-IntfAddrMap getInterfaceAddrs()
-{
-    IntfAddrMap intfMap{};
-    struct ifaddrs* ifaddr = nullptr;
-
-    // attempt to fill struct with ifaddrs
-    if (getifaddrs(&ifaddr) == -1)
-    {
-        auto error = errno;
-        log<level::ERR>("Error occurred during the getifaddrs call",
-                        entry("ERRNO=%s", strerror(error)));
-        elog<InternalFailure>();
-    }
-
-    AddrPtr ifaddrPtr(ifaddr);
-    ifaddr = nullptr;
-
-    std::string intfName{};
-
-    for (ifaddrs* ifa = ifaddrPtr.get(); ifa != nullptr; ifa = ifa->ifa_next)
-    {
-        // walk interfaces
-        if (ifa->ifa_addr == nullptr)
-        {
-            continue;
-        }
-
-        // get only INET interfaces not ipv6
-        if (ifa->ifa_addr->sa_family == AF_INET ||
-            ifa->ifa_addr->sa_family == AF_INET6)
-        {
-            // if loopback, or not running ignore
-            if ((ifa->ifa_flags & IFF_LOOPBACK) ||
-                !(ifa->ifa_flags & IFF_RUNNING))
-            {
-                continue;
-            }
-            intfName = ifa->ifa_name;
-            AddrInfo info{};
-            char ip[INET6_ADDRSTRLEN] = {0};
-            char subnetMask[INET6_ADDRSTRLEN] = {0};
-
-            if (ifa->ifa_addr->sa_family == AF_INET)
-            {
-
-                inet_ntop(ifa->ifa_addr->sa_family,
-                          &(((struct sockaddr_in*)(ifa->ifa_addr))->sin_addr),
-                          ip, sizeof(ip));
-
-                inet_ntop(
-                    ifa->ifa_addr->sa_family,
-                    &(((struct sockaddr_in*)(ifa->ifa_netmask))->sin_addr),
-                    subnetMask, sizeof(subnetMask));
-            }
-            else
-            {
-                inet_ntop(ifa->ifa_addr->sa_family,
-                          &(((struct sockaddr_in6*)(ifa->ifa_addr))->sin6_addr),
-                          ip, sizeof(ip));
-
-                inet_ntop(
-                    ifa->ifa_addr->sa_family,
-                    &(((struct sockaddr_in6*)(ifa->ifa_netmask))->sin6_addr),
-                    subnetMask, sizeof(subnetMask));
-            }
-
-            info.addrType = ifa->ifa_addr->sa_family;
-            info.ipaddress = ip;
-            info.prefix = toCidr(info.addrType, std::string(subnetMask));
-            intfMap[intfName].push_back(info);
-        }
-    }
-    return intfMap;
-}
-
 InterfaceList getInterfaces()
 {
     InterfaceList interfaces{};
diff --git a/src/util.hpp b/src/util.hpp
index fd00b31..43c231f 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -26,8 +26,6 @@
 constexpr auto IPV4_MIN_PREFIX_LENGTH = 1;
 constexpr auto IPV4_MAX_PREFIX_LENGTH = 32;
 constexpr auto IPV6_MAX_PREFIX_LENGTH = 128;
-constexpr auto IPV4_PREFIX = "169.254";
-constexpr auto IPV6_PREFIX = "fe80";
 
 namespace mac_address
 {
@@ -78,13 +76,6 @@
 constexpr auto networkdService = "systemd-networkd.service";
 constexpr auto timeSynchdService = "systemd-timesyncd.service";
 
-/* @brief converts the given subnet into prefix notation.
- * @param[in] addressFamily - IP address family(AF_INET/AF_INET6).
- * @param[in] mask - Subnet Mask.
- * @returns prefix.
- */
-uint8_t toCidr(int addressFamily, const std::string& mask);
-
 /* @brief converts a sockaddr for the specified address family into
  *        a type_safe InAddrAny.
  * @param[in] addressFamily - The address family of the buf
@@ -100,19 +91,6 @@
 std::string toString(const struct in_addr& addr);
 std::string toString(const struct in6_addr& addr);
 
-/* @brief converts the prefix into subnetmask.
- * @param[in] addressFamily - IP address family(AF_INET/AF_INET6).
- * @param[in] prefix - prefix length.
- * @returns subnet mask.
- */
-std::string toMask(int addressFamily, uint8_t prefix);
-
-/* @brief checks that the given ip address is link local or not.
- * @param[in] address - IP address.
- * @returns true if it is linklocal otherwise false.
- */
-bool isLinkLocalIP(const std::string& address);
-
 /* @brief checks that the given ip address valid or not.
  * @param[in] addressFamily - IP address family(AF_INET/AF_INET6).
  * @param[in] address - IP address.
@@ -127,12 +105,6 @@
  */
 bool isValidPrefix(int addressFamily, uint8_t prefixLength);
 
-/** @brief Gets the map of interface and the associated
- *         address.
- *  @returns map of interface and the address.
- */
-IntfAddrMap getInterfaceAddrs();
-
 /** @brief Get all the interfaces from the system.
  *  @returns list of interface names.
  */
diff --git a/test/meson.build b/test/meson.build
index 7cd906a..b501080 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -46,6 +46,7 @@
 tests = [
   'config_parser',
   'ethernet_interface',
+  'ipaddress',
   'neighbor',
   'netlink',
   'network_manager',
diff --git a/test/test_ipaddress.cpp b/test/test_ipaddress.cpp
new file mode 100644
index 0000000..f5a6147
--- /dev/null
+++ b/test/test_ipaddress.cpp
@@ -0,0 +1,207 @@
+#include "ipaddress.hpp"
+#include "util.hpp"
+
+#include <arpa/inet.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+#include <cstring>
+#include <stdexcept>
+#include <stdplus/raw.hpp>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace phosphor
+{
+namespace network
+{
+namespace detail
+{
+
+TEST(ParseAddress, NotAddressType)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWLINK;
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    EXPECT_THROW(parseAddress(filter, hdr, "", addresses), std::runtime_error);
+    EXPECT_EQ(0, addresses.size());
+}
+
+TEST(ParseAddress, SmallMsg)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWADDR;
+    std::string data = "1";
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    EXPECT_THROW(parseAddress(filter, hdr, data, addresses),
+                 std::runtime_error);
+    EXPECT_EQ(0, addresses.size());
+}
+
+TEST(ParseAddress, NoAttrs)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWADDR;
+    ifaddrmsg msg{};
+    msg.ifa_family = AF_INET;
+    msg.ifa_prefixlen = 24;
+    msg.ifa_index = 1;
+    msg.ifa_scope = RT_SCOPE_UNIVERSE;
+    std::string data;
+    data.append(reinterpret_cast<char*>(&msg), sizeof(msg));
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    EXPECT_THROW(parseAddress(filter, hdr, data, addresses),
+                 std::runtime_error);
+    EXPECT_EQ(0, addresses.size());
+}
+
+TEST(ParseAddress, NoAddress)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWADDR;
+    ifaddrmsg msg{};
+    msg.ifa_family = AF_INET;
+    msg.ifa_prefixlen = 24;
+    msg.ifa_index = 1;
+    msg.ifa_scope = RT_SCOPE_UNIVERSE;
+    in_addr addr{};
+    rtattr local{};
+    constexpr auto len = RTA_LENGTH(sizeof(addr));
+    local.rta_len = len;
+    local.rta_type = IFA_LOCAL;
+    char localbuf[RTA_ALIGN(len)];
+    std::memset(localbuf, '\0', sizeof(localbuf));
+    std::memcpy(localbuf, &local, sizeof(local));
+    std::memcpy(RTA_DATA(localbuf), &addr, sizeof(addr));
+    std::string data;
+    data.append(reinterpret_cast<char*>(&msg), sizeof(msg));
+    data.append(reinterpret_cast<char*>(&localbuf), sizeof(localbuf));
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    EXPECT_THROW(parseAddress(filter, hdr, data, addresses),
+                 std::runtime_error);
+    EXPECT_EQ(0, addresses.size());
+}
+
+TEST(ParseAddress, FilterInterface)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWADDR;
+    ifaddrmsg msg{};
+    msg.ifa_family = AF_INET;
+    msg.ifa_prefixlen = 24;
+    msg.ifa_index = 2;
+    msg.ifa_scope = RT_SCOPE_UNIVERSE;
+    in_addr addr;
+    ASSERT_EQ(1, inet_pton(msg.ifa_family, "192.168.10.1", &addr));
+    rtattr address{};
+    constexpr auto len = RTA_LENGTH(sizeof(addr));
+    address.rta_len = len;
+    address.rta_type = IFA_ADDRESS;
+    char addressbuf[RTA_ALIGN(len)];
+    std::memset(addressbuf, '\0', sizeof(addressbuf));
+    std::memcpy(addressbuf, &address, sizeof(address));
+    std::memcpy(RTA_DATA(addressbuf), &addr, sizeof(addr));
+    std::string data;
+    data.append(reinterpret_cast<char*>(&msg), sizeof(msg));
+    data.append(reinterpret_cast<char*>(&addressbuf), sizeof(addressbuf));
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    filter.interface = 1;
+    parseAddress(filter, hdr, data, addresses);
+    EXPECT_EQ(0, addresses.size());
+    filter.interface = 2;
+    parseAddress(filter, hdr, data, addresses);
+    EXPECT_EQ(1, addresses.size());
+    EXPECT_EQ(msg.ifa_index, addresses[0].interface);
+    EXPECT_EQ(msg.ifa_scope, addresses[0].scope);
+    EXPECT_EQ(msg.ifa_prefixlen, addresses[0].prefix);
+    EXPECT_TRUE(
+        stdplus::raw::equal(addr, std::get<in_addr>(addresses[0].address)));
+}
+
+TEST(ParseNeighbor, FilterScope)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWADDR;
+    ifaddrmsg msg{};
+    msg.ifa_family = AF_INET;
+    msg.ifa_prefixlen = 24;
+    msg.ifa_index = 2;
+    msg.ifa_scope = RT_SCOPE_SITE;
+    in_addr addr;
+    ASSERT_EQ(1, inet_pton(msg.ifa_family, "192.168.10.1", &addr));
+    rtattr address{};
+    constexpr auto len = RTA_LENGTH(sizeof(addr));
+    address.rta_len = len;
+    address.rta_type = IFA_ADDRESS;
+    char addressbuf[RTA_ALIGN(len)];
+    std::memset(addressbuf, '\0', sizeof(addressbuf));
+    std::memcpy(addressbuf, &address, sizeof(address));
+    std::memcpy(RTA_DATA(addressbuf), &addr, sizeof(addr));
+    std::string data;
+    data.append(reinterpret_cast<char*>(&msg), sizeof(msg));
+    data.append(reinterpret_cast<char*>(&addressbuf), sizeof(addressbuf));
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    filter.scope = RT_SCOPE_UNIVERSE;
+    parseAddress(filter, hdr, data, addresses);
+    EXPECT_EQ(0, addresses.size());
+    filter.scope = RT_SCOPE_SITE;
+    parseAddress(filter, hdr, data, addresses);
+    EXPECT_EQ(1, addresses.size());
+    EXPECT_EQ(msg.ifa_index, addresses[0].interface);
+    EXPECT_EQ(msg.ifa_scope, addresses[0].scope);
+    EXPECT_EQ(msg.ifa_prefixlen, addresses[0].prefix);
+    EXPECT_TRUE(
+        stdplus::raw::equal(addr, std::get<in_addr>(addresses[0].address)));
+}
+
+TEST(ParseNeighbor, NoFilter)
+{
+    nlmsghdr hdr{};
+    hdr.nlmsg_type = RTM_NEWADDR;
+    ifaddrmsg msg{};
+    msg.ifa_family = AF_INET6;
+    msg.ifa_prefixlen = 24;
+    msg.ifa_index = 1;
+    msg.ifa_scope = RT_SCOPE_UNIVERSE;
+    in6_addr addr;
+    ASSERT_EQ(1, inet_pton(msg.ifa_family, "fd00::2", &addr));
+    rtattr address{};
+    constexpr auto len = RTA_LENGTH(sizeof(addr));
+    address.rta_len = len;
+    address.rta_type = IFA_ADDRESS;
+    char addressbuf[RTA_ALIGN(len)];
+    std::memset(addressbuf, '\0', sizeof(addressbuf));
+    std::memcpy(addressbuf, &address, sizeof(address));
+    std::memcpy(RTA_DATA(addressbuf), &addr, sizeof(addr));
+    std::string data;
+    data.append(reinterpret_cast<char*>(&msg), sizeof(msg));
+    data.append(reinterpret_cast<char*>(&addressbuf), sizeof(addressbuf));
+    AddressFilter filter;
+
+    std::vector<AddressInfo> addresses;
+    parseAddress(filter, hdr, data, addresses);
+    EXPECT_EQ(1, addresses.size());
+    EXPECT_EQ(msg.ifa_index, addresses[0].interface);
+    EXPECT_EQ(msg.ifa_scope, addresses[0].scope);
+    EXPECT_EQ(msg.ifa_prefixlen, addresses[0].prefix);
+    EXPECT_TRUE(
+        stdplus::raw::equal(addr, std::get<in6_addr>(addresses[0].address)));
+}
+
+} // namespace detail
+} // namespace network
+} // namespace phosphor
diff --git a/test/test_util.cpp b/test/test_util.cpp
index fc895cf..4a50a26 100644
--- a/test/test_util.cpp
+++ b/test/test_util.cpp
@@ -127,127 +127,6 @@
     EXPECT_EQ(false, isValidPrefix(AF_INET, prefixLength));
 }
 
-TEST_F(TestUtil, ConvertV4MasktoPrefix)
-{
-    std::string mask = "255.255.255.0";
-    uint8_t prefix = toCidr(AF_INET, mask);
-    EXPECT_EQ(prefix, 24);
-
-    mask = "255.255.255.255";
-    prefix = toCidr(AF_INET, mask);
-    EXPECT_EQ(prefix, 32);
-
-    mask = "255.255.0.0";
-    prefix = toCidr(AF_INET, mask);
-    EXPECT_EQ(prefix, 16);
-
-    mask = "255.0.0.0";
-    prefix = toCidr(AF_INET, mask);
-    EXPECT_EQ(prefix, 8);
-
-    mask = "255.224.0.0";
-    prefix = toCidr(AF_INET, mask);
-    EXPECT_EQ(prefix, 11);
-
-    // Invalid Mask
-    mask = "255.0.255.0";
-    prefix = toCidr(AF_INET, mask);
-    EXPECT_EQ(prefix, 0);
-}
-
-TEST_F(TestUtil, convertV6MasktoPrefix)
-{
-    std::string mask = "ffff:ffff::";
-    uint8_t prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 32);
-
-    mask = "::";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-
-    mask = "ffff:ffff:ffff::";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 48);
-
-    mask = "ffff:ffff:fc00::";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 38);
-
-    mask = "ffff:0:0:0:0:0:0:0";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 16);
-
-    mask = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 128);
-
-    mask = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffc";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 126);
-
-    mask = "ffff:ffff:ffff:ffff::";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 64);
-
-    // Invalid Masks
-    mask = "ffff:0fff::";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-
-    mask = "ffff:fgff::";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-
-    mask = "ffff:0:0:6:0:0:0:0";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-
-    mask = ":";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-
-    mask = "abcd:efgh:ijkl:mnop:pqrs:tuvw:xyz:abcd";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-
-    mask = "ffff:0:0:0:0:0:0";
-    prefix = toCidr(AF_INET6, mask);
-    EXPECT_EQ(prefix, 0);
-}
-
-TEST_F(TestUtil, isLinkLocaladdress)
-{
-    std::string ipaddress = "fe80:fec0::";
-    EXPECT_TRUE(isLinkLocalIP(ipaddress));
-
-    ipaddress = "2000:fe80:789::";
-    EXPECT_FALSE(isLinkLocalIP(ipaddress));
-
-    ipaddress = "2000:fe80::";
-    EXPECT_FALSE(isLinkLocalIP(ipaddress));
-
-    ipaddress = "169.254.3.3";
-    EXPECT_TRUE(isLinkLocalIP(ipaddress));
-
-    ipaddress = "3.169.254.3";
-    EXPECT_FALSE(isLinkLocalIP(ipaddress));
-
-    ipaddress = "3.3.169.254";
-    EXPECT_FALSE(isLinkLocalIP(ipaddress));
-}
-
-TEST_F(TestUtil, convertPrefixToMask)
-{
-    std::string mask = toMask(AF_INET, 24);
-    EXPECT_EQ(mask, "255.255.255.0");
-
-    mask = toMask(AF_INET, 8);
-    EXPECT_EQ(mask, "255.0.0.0");
-
-    mask = toMask(AF_INET, 27);
-    EXPECT_EQ(mask, "255.255.255.224");
-}
-
 TEST_F(TestUtil, InterfaceToUbootEthAddr)
 {
     EXPECT_EQ(std::nullopt, interfaceToUbootEthAddr("et"));