5:33 p.m.
This just copies over the code from iwd. No changes there except the
prefix of the functions name.
Unfortunatly, the unit test can only test the get/dump function
because the setters need root permissions. For this we need some sort
of sandbox. Does anyone have any ideas for this?
While writing the test case I noticed some inconsistency in the naming
sceme:
The IPv6 functions are consistent in the naming sceme, always
append ipv6 after the first name:
rtnl_ifaddr_ipv6_extract
rtnl_ifaddr_ipv6_get
rtnl_ifaddr_ipv6_add
rtnl_ifaddr_ipv6_delete
rtnl_route_ipv6_add_gateway
rtnl_route_ipv6_delete_gateway
For the IPv4 functions it's either a plain 'ifaddr' infix or somewhere ipv4
in the name:
rtnl_ifaddr_extract
rtnl_ifaddr_get
rtnl_ifaddr_add
rtnl_ifaddr_delete
rtnl_route_extract_ipv4
rtnl_route_dump_ipv4
-> drop ipv4?
rtnl_route_ipv4_add_connected
rtnl_route_ipv4_add_gateway
-> drop ipv4?
And there are the setters:
rtnl_set_linkmode_and_operstate
rtnl_set_mac
rtnl_set_powered
Is this the standard naming sceme?
Thanks,
Daniel
Daniel Wagner (2):
rtnl: Add initial rtnl support
unit: Add l_rtnl_* unit tests
.gitignore | 1 +
Makefile.am | 5 +
ell/ell.h | 1 +
ell/rtnl.c | 641 +++++++++++++++++++++++++++++++++++++++++++++++
ell/rtnl.h | 119 +++++++++
unit/test-rtnl.c | 236 +++++++++++++++++
6 files changed, 1003 insertions(+)
create mode 100644 ell/rtnl.c
create mode 100644 ell/rtnl.h
create mode 100644 unit/test-rtnl.c
--
2.25.0
5:33 p.m.
New subject: [PATCH 1/2] rtnl: Add initial rtnl support
Import from iwd the rtnlutil helper code. There are no changes expect
prefix the name of the functions.
---
Makefile.am | 2 +
ell/ell.h | 1 +
ell/rtnl.c | 641 ++++++++++++++++++++++++++++++++++++++++++++++++++++
ell/rtnl.h | 119 ++++++++++
4 files changed, 763 insertions(+)
create mode 100644 ell/rtnl.c
create mode 100644 ell/rtnl.h
diff --git a/Makefile.am b/Makefile.am
index 3ead678ff194..453f0d1b42d0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -34,6 +34,7 @@ pkginclude_HEADERS = ell/ell.h \
ell/checksum.h \
ell/netlink.h \
ell/genl.h \
+ ell/rtnl.h \
ell/dbus.h \
ell/dbus-service.h \
ell/dbus-client.h \
@@ -85,6 +86,7 @@ ell_libell_la_SOURCES = $(linux_headers) \
ell/netlink.c \
ell/genl-private.h \
ell/genl.c \
+ ell/rtnl.c \
ell/dbus-private.h \
ell/dbus.c \
ell/dbus-message.c \
diff --git a/ell/ell.h b/ell/ell.h
index 3bb91851fe94..d16d1b2044be 100644
--- a/ell/ell.h
+++ b/ell/ell.h
@@ -52,6 +52,7 @@
#include <ell/net.h>
#include <ell/netlink.h>
#include <ell/genl.h>
+#include <ell/rtnl.h>
#include <ell/dbus.h>
#include <ell/dbus-service.h>
#include <ell/dbus-client.h>
diff --git a/ell/rtnl.c b/ell/rtnl.c
new file mode 100644
index 000000000000..e4ead316a673
--- /dev/null
+++ b/ell/rtnl.c
@@ -0,0 +1,641 @@
+/*
+ *
+ * Embedded Linux library
+ *
+ * Copyright (C) 2019 Intel Corporation. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <linux/if.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#include "util.h"
+#include "netlink.h"
+#include "log.h"
+#include "rtnl.h"
+
+static size_t rta_add_u8(void *rta_buf, unsigned short type, uint8_t value)
+{
+ struct rtattr *rta = rta_buf;
+
+ rta->rta_len = RTA_LENGTH(sizeof(uint8_t));
+ rta->rta_type = type;
+ *((uint8_t *) RTA_DATA(rta)) = value;
+
+ return RTA_SPACE(sizeof(uint8_t));
+}
+
+static size_t rta_add_u32(void *rta_buf, unsigned short type, uint32_t value)
+{
+ struct rtattr *rta = rta_buf;
+
+ rta->rta_len = RTA_LENGTH(sizeof(uint32_t));
+ rta->rta_type = type;
+ *((uint32_t *) RTA_DATA(rta)) = value;
+
+ return RTA_SPACE(sizeof(uint32_t));
+}
+
+static size_t rta_add_data(void *rta_buf, unsigned short type, void *data,
+ size_t data_len)
+{
+ struct rtattr *rta = rta_buf;
+
+ rta->rta_len = RTA_LENGTH(data_len);
+ rta->rta_type = type;
+ memcpy(RTA_DATA(rta), data, data_len);
+
+ return RTA_SPACE(data_len);
+}
+
+uint32_t l_rtnl_set_linkmode_and_operstate(struct l_netlink *rtnl, int ifindex,
+ uint8_t linkmode, uint8_t operstate,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifinfomsg *rtmmsg;
+ void *rta_buf;
+ size_t bufsize;
+ uint32_t id;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct ifinfomsg)) +
+ RTA_SPACE(sizeof(uint8_t)) + RTA_SPACE(sizeof(uint8_t));
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->ifi_family = AF_UNSPEC;
+ rtmmsg->ifi_index = ifindex;
+
+ rta_buf = (void *) rtmmsg + NLMSG_ALIGN(sizeof(struct ifinfomsg));
+
+ rta_buf += rta_add_u8(rta_buf, IFLA_LINKMODE, linkmode);
+ rta_buf += rta_add_u8(rta_buf, IFLA_OPERSTATE, operstate);
+
+ id = l_netlink_send(rtnl, RTM_SETLINK, 0, rtmmsg,
+ rta_buf - (void *) rtmmsg,
+ cb, user_data, destroy);
+ l_free(rtmmsg);
+
+ return id;
+}
+
+uint32_t l_rtnl_set_mac(struct l_netlink *rtnl, int ifindex,
+ const uint8_t addr[static 6],
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifinfomsg *rtmmsg;
+ void *rta_buf;
+ size_t bufsize;
+ uint32_t id;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct ifinfomsg)) + RTA_SPACE(6);
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->ifi_family = AF_UNSPEC;
+ rtmmsg->ifi_index = ifindex;
+
+ rta_buf = (void *) rtmmsg + NLMSG_ALIGN(sizeof(struct ifinfomsg));
+
+ rta_buf += rta_add_data(rta_buf, IFLA_ADDRESS, (void *) addr, 6);
+
+ id = l_netlink_send(rtnl, RTM_SETLINK, 0, rtmmsg,
+ rta_buf - (void *) rtmmsg,
+ cb, user_data, destroy);
+ l_free(rtmmsg);
+
+ return id;
+}
+
+uint32_t l_rtnl_set_powered(struct l_netlink *rtnl, int ifindex, bool powered,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifinfomsg *rtmmsg;
+ size_t bufsize;
+ uint32_t id;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct ifinfomsg));
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->ifi_family = AF_UNSPEC;
+ rtmmsg->ifi_index = ifindex;
+ rtmmsg->ifi_change = IFF_UP;
+ rtmmsg->ifi_flags = powered ? IFF_UP : 0;
+
+ id = l_netlink_send(rtnl, RTM_SETLINK, 0, rtmmsg, bufsize,
+ cb, user_data, destroy);
+ l_free(rtmmsg);
+
+ return id;
+}
+
+void l_rtnl_ifaddr_extract(const struct ifaddrmsg *ifa, int bytes,
+ char **label, char **ip, char **broadcast)
+{
+ struct in_addr in_addr;
+ struct rtattr *attr;
+
+ for (attr = IFA_RTA(ifa); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFA_LOCAL:
+ if (!ip)
+ break;
+
+ in_addr = *((struct in_addr *) RTA_DATA(attr));
+ *ip = l_strdup(inet_ntoa(in_addr));
+
+ break;
+ case IFA_BROADCAST:
+ if (!broadcast)
+ break;
+
+ in_addr = *((struct in_addr *) RTA_DATA(attr));
+ *broadcast = l_strdup(inet_ntoa(in_addr));
+
+ break;
+ case IFA_LABEL:
+ if (!label)
+ break;
+
+ *label = l_strdup(RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+uint32_t l_rtnl_ifaddr_get(struct l_netlink *rtnl, l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifaddrmsg *rtmmsg;
+ uint32_t id;
+
+ rtmmsg = l_malloc(sizeof(struct ifaddrmsg));
+ memset(rtmmsg, 0, sizeof(struct ifaddrmsg));
+
+ rtmmsg->ifa_family = AF_INET;
+
+ id = l_netlink_send(rtnl, RTM_GETADDR, NLM_F_DUMP, rtmmsg,
+ sizeof(struct ifaddrmsg), cb, user_data,
+ destroy);
+
+ l_free(rtmmsg);
+
+ return id;
+}
+
+static uint32_t l_rtnl_ifaddr_change(struct l_netlink *rtnl, uint16_t nlmsg_type,
+ int ifindex, uint8_t prefix_len,
+ const char *ip, const char *broadcast,
+ l_netlink_command_func_t
+ cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifaddrmsg *rtmmsg;
+ struct in_addr in_addr;
+ void *rta_buf;
+ size_t bufsize;
+ uint32_t id;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
+ RTA_SPACE(sizeof(struct in_addr)) +
+ RTA_SPACE(sizeof(struct in_addr));
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->ifa_index = ifindex;
+ rtmmsg->ifa_family = AF_INET;
+ rtmmsg->ifa_flags = IFA_F_PERMANENT;
+ rtmmsg->ifa_scope = RT_SCOPE_UNIVERSE;
+ rtmmsg->ifa_prefixlen = prefix_len;
+
+ rta_buf = (void *) rtmmsg + NLMSG_ALIGN(sizeof(struct ifaddrmsg));
+
+ if (inet_pton(AF_INET, ip, &in_addr) < 1) {
+ l_free(rtmmsg);
+ return 0;
+ }
+
+ rta_buf += rta_add_data(rta_buf, IFA_LOCAL, &in_addr,
+ sizeof(struct in_addr));
+
+ if (broadcast) {
+ if (inet_pton(AF_INET, broadcast, &in_addr) < 1) {
+ l_free(rtmmsg);
+ return 0;
+ }
+ } else {
+ in_addr.s_addr = in_addr.s_addr |
+ htonl(0xFFFFFFFFLU >> prefix_len);
+ }
+
+ rta_buf += rta_add_data(rta_buf, IFA_BROADCAST, &in_addr,
+ sizeof(struct in_addr));
+
+ id = l_netlink_send(rtnl, nlmsg_type, 0, rtmmsg,
+ rta_buf - (void *) rtmmsg, cb,
+ user_data, destroy);
+ l_free(rtmmsg);
+
+ return id;
+}
+
+uint32_t l_rtnl_ifaddr_add(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ const char *broadcast,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_ifaddr_change(rtnl, RTM_NEWADDR, ifindex, prefix_len, ip,
+ broadcast, cb, user_data, destroy);
+}
+
+uint32_t l_rtnl_ifaddr_delete(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ const char *broadcast,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_ifaddr_change(rtnl, RTM_DELADDR, ifindex, prefix_len, ip,
+ broadcast, cb, user_data, destroy);
+}
+
+void l_rtnl_route_extract_ipv4(const struct rtmsg *rtmsg, uint32_t len,
+ uint32_t *ifindex, char **dst, char **gateway,
+ char **src)
+{
+ struct in_addr in_addr;
+ struct rtattr *attr;
+
+ for (attr = RTM_RTA(rtmsg); RTA_OK(attr, len);
+ attr = RTA_NEXT(attr, len)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ if (!dst)
+ break;
+
+ in_addr = *((struct in_addr *) RTA_DATA(attr));
+ *dst = l_strdup(inet_ntoa(in_addr));
+
+ break;
+ case RTA_GATEWAY:
+ if (!gateway)
+ break;
+
+ in_addr = *((struct in_addr *) RTA_DATA(attr));
+ *gateway = l_strdup(inet_ntoa(in_addr));
+
+ break;
+ case RTA_PREFSRC:
+ if (!src)
+ break;
+
+ in_addr = *((struct in_addr *) RTA_DATA(attr));
+ *src = l_strdup(inet_ntoa(in_addr));
+
+ break;
+ case RTA_OIF:
+ if (!ifindex)
+ break;
+
+ *ifindex = *((uint32_t *) RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+uint32_t l_rtnl_route_dump_ipv4(struct l_netlink *rtnl,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct rtmsg rtmsg;
+
+ memset(&rtmsg, 0, sizeof(struct rtmsg));
+ rtmsg.rtm_family = AF_INET;
+
+ return l_netlink_send(rtnl, RTM_GETROUTE, NLM_F_DUMP, &rtmsg,
+ sizeof(struct rtmsg), cb, user_data,
+ destroy);
+}
+
+static uint32_t l_rtnl_route_add(struct l_netlink *rtnl, int ifindex,
+ uint8_t scope, uint8_t dst_len,
+ const char *dst, const char *gateway,
+ const char *src,
+ uint32_t priority_offset, uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ L_AUTO_FREE_VAR(struct rtmsg *, rtmmsg) = NULL;
+ struct in_addr in_addr;
+ size_t bufsize;
+ void *rta_buf;
+ uint16_t flags;
+
+ if (!dst && !gateway)
+ return 0;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct rtmsg)) +
+ RTA_SPACE(sizeof(uint32_t)) +
+ (priority_offset ? RTA_SPACE(sizeof(uint32_t)) : 0) +
+ (gateway ? RTA_SPACE(sizeof(struct in_addr)) : 0) +
+ (src ? RTA_SPACE(sizeof(struct in_addr)) : 0) +
+ (dst ? RTA_SPACE(sizeof(struct in_addr)) : 0);
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->rtm_family = AF_INET;
+ rtmmsg->rtm_table = RT_TABLE_MAIN;
+ rtmmsg->rtm_protocol = proto;
+ rtmmsg->rtm_type = RTN_UNICAST;
+ rtmmsg->rtm_scope = scope;
+
+ flags = NLM_F_CREATE | NLM_F_REPLACE;
+
+ rta_buf = (void *) rtmmsg + NLMSG_ALIGN(sizeof(struct rtmsg));
+ rta_buf += rta_add_u32(rta_buf, RTA_OIF, ifindex);
+
+ if (priority_offset)
+ rta_buf += rta_add_u32(rta_buf, RTA_PRIORITY,
+ priority_offset + ifindex);
+
+ if (dst) {
+ if (inet_pton(AF_INET, dst, &in_addr) < 1)
+ return 0;
+
+ rtmmsg->rtm_dst_len = dst_len;
+ rta_buf += rta_add_data(rta_buf, RTA_DST, &in_addr,
+ sizeof(struct in_addr));
+ }
+
+ if (gateway) {
+ if (inet_pton(AF_INET, gateway, &in_addr) < 1)
+ return 0;
+
+ rta_buf += rta_add_data(rta_buf, RTA_GATEWAY, &in_addr,
+ sizeof(struct in_addr));
+ }
+
+ if (src) {
+ if (inet_pton(AF_INET, src, &in_addr) < 1)
+ return 0;
+
+ rtmmsg->rtm_src_len = 32;
+ rta_buf += rta_add_data(rta_buf, RTA_PREFSRC, &in_addr,
+ sizeof(struct in_addr));
+ }
+
+ return l_netlink_send(rtnl, RTM_NEWROUTE, flags, rtmmsg,
+ rta_buf - (void *) rtmmsg, cb, user_data,
+ destroy);
+}
+
+uint32_t l_rtnl_route_ipv4_add_connected(struct l_netlink *rtnl, int ifindex,
+ uint8_t dst_len, const char *dst,
+ const char *src, uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_route_add(rtnl, ifindex, RT_SCOPE_LINK, dst_len, dst, NULL,
+ src, 0, proto, cb, user_data, destroy);
+}
+
+uint32_t l_rtnl_route_ipv4_add_gateway(struct l_netlink *rtnl, int ifindex,
+ const char *gateway, const char *src,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_route_add(rtnl, ifindex, RT_SCOPE_UNIVERSE, 0, NULL,
+ gateway, src, priority_offset, proto, cb,
+ user_data, destroy);
+}
+
+void l_rtnl_ifaddr_ipv6_extract(const struct ifaddrmsg *ifa, int len, char **ip)
+{
+ struct in6_addr in6_addr;
+ struct rtattr *attr;
+ char address[128];
+
+ for (attr = IFA_RTA(ifa); RTA_OK(attr, len);
+ attr = RTA_NEXT(attr, len)) {
+ switch (attr->rta_type) {
+ case IFA_ADDRESS:
+ if (!ip)
+ break;
+
+ memcpy(&in6_addr.s6_addr, RTA_DATA(attr),
+ sizeof(in6_addr.s6_addr));
+
+ if (!inet_ntop(AF_INET6, &in6_addr, address,
+ INET6_ADDRSTRLEN)) {
+
+ l_error("rtnl: Failed to extract IPv6 address");
+ break;
+ }
+
+ *ip = l_strdup(address);
+
+ break;
+ }
+ }
+}
+
+uint32_t l_rtnl_ifaddr_ipv6_get(struct l_netlink *rtnl,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifaddrmsg *rtmmsg;
+ uint32_t id;
+
+ rtmmsg = l_malloc(sizeof(struct ifaddrmsg));
+ memset(rtmmsg, 0, sizeof(struct ifaddrmsg));
+
+ rtmmsg->ifa_family = AF_INET6;
+
+ id = l_netlink_send(rtnl, RTM_GETADDR, NLM_F_DUMP, rtmmsg,
+ sizeof(struct ifaddrmsg), cb, user_data,
+ destroy);
+
+ l_free(rtmmsg);
+
+ return id;
+}
+
+static uint32_t l_rtnl_ifaddr_ipv6_change(struct l_netlink *rtnl,
+ uint16_t nlmsg_type,
+ int ifindex, uint8_t prefix_len,
+ const char *ip,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ struct ifaddrmsg *rtmmsg;
+ struct in6_addr in6_addr;
+ void *rta_buf;
+ size_t bufsize;
+ uint32_t id;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
+ RTA_SPACE(sizeof(struct in6_addr));
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->ifa_index = ifindex;
+ rtmmsg->ifa_family = AF_INET6;
+ rtmmsg->ifa_flags = IFA_F_PERMANENT;
+ rtmmsg->ifa_scope = RT_SCOPE_UNIVERSE;
+ rtmmsg->ifa_prefixlen = prefix_len;
+
+ rta_buf = (void *) rtmmsg + NLMSG_ALIGN(sizeof(struct ifaddrmsg));
+
+ if (inet_pton(AF_INET6, ip, &in6_addr) < 1) {
+ l_free(rtmmsg);
+ return 0;
+ }
+
+ rta_buf += rta_add_data(rta_buf, IFA_LOCAL, &in6_addr,
+ sizeof(struct in6_addr));
+
+ id = l_netlink_send(rtnl, nlmsg_type, 0, rtmmsg,
+ rta_buf - (void *) rtmmsg, cb,
+ user_data, destroy);
+ l_free(rtmmsg);
+
+ return id;
+}
+
+uint32_t l_rtnl_ifaddr_ipv6_add(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_ifaddr_ipv6_change(rtnl, RTM_NEWADDR, ifindex, prefix_len,
+ ip, cb, user_data, destroy);
+}
+
+uint32_t l_rtnl_ifaddr_ipv6_delete(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_ifaddr_ipv6_change(rtnl, RTM_DELADDR, ifindex, prefix_len,
+ ip, cb, user_data, destroy);
+}
+
+static uint32_t l_rtnl_route_ipv6_change(struct l_netlink *rtnl,
+ uint16_t nlmsg_type, int ifindex,
+ const char *gateway,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ L_AUTO_FREE_VAR(struct rtmsg *, rtmmsg) = NULL;
+ struct in6_addr in6_addr;
+ size_t bufsize;
+ void *rta_buf;
+ uint16_t flags;
+
+ if (!gateway)
+ return 0;
+
+ bufsize = NLMSG_ALIGN(sizeof(struct rtmsg)) +
+ RTA_SPACE(sizeof(uint32_t)) +
+ (priority_offset ? RTA_SPACE(sizeof(uint32_t)) : 0) +
+ RTA_SPACE(sizeof(struct in6_addr));
+
+ rtmmsg = l_malloc(bufsize);
+ memset(rtmmsg, 0, bufsize);
+
+ rtmmsg->rtm_family = AF_INET6;
+ rtmmsg->rtm_table = RT_TABLE_MAIN;
+ rtmmsg->rtm_protocol = proto;
+ rtmmsg->rtm_type = RTN_UNICAST;
+ rtmmsg->rtm_scope = RT_SCOPE_UNIVERSE;
+
+ flags = NLM_F_CREATE | NLM_F_REPLACE;
+
+ rta_buf = (void *) rtmmsg + NLMSG_ALIGN(sizeof(struct rtmsg));
+ rta_buf += rta_add_u32(rta_buf, RTA_OIF, ifindex);
+
+ if (priority_offset)
+ rta_buf += rta_add_u32(rta_buf, RTA_PRIORITY,
+ priority_offset + ifindex);
+
+ if (gateway) {
+ if (inet_pton(AF_INET6, gateway, &in6_addr) < 1)
+ return 0;
+
+ rta_buf += rta_add_data(rta_buf, RTA_GATEWAY, &in6_addr,
+ sizeof(struct in6_addr));
+ }
+
+ return l_netlink_send(rtnl, nlmsg_type, flags, rtmmsg,
+ rta_buf - (void *) rtmmsg, cb, user_data,
+ destroy);
+}
+
+uint32_t l_rtnl_route_ipv6_add_gateway(struct l_netlink *rtnl, int ifindex,
+ const char *gateway,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_route_ipv6_change(rtnl, RTM_NEWROUTE, ifindex, gateway,
+ priority_offset, proto, cb,
+ user_data, destroy);
+}
+
+uint32_t l_rtnl_route_ipv6_delete_gateway(struct l_netlink *rtnl, int ifindex,
+ const char *gateway,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy)
+{
+ return l_rtnl_route_ipv6_change(rtnl, RTM_DELROUTE, ifindex, gateway,
+ priority_offset, proto, cb,
+ user_data, destroy);
+}
diff --git a/ell/rtnl.h b/ell/rtnl.h
new file mode 100644
index 000000000000..14d933313db2
--- /dev/null
+++ b/ell/rtnl.h
@@ -0,0 +1,119 @@
+/*
+ *
+ * Embedded Linux library
+ *
+ * Copyright (C) 2019 Intel Corporation. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __ELL_RTNL_H
+#define __ELL_RTNL_H
+
+#include <stdint.h>
+#include <linux/rtnetlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t l_rtnl_set_linkmode_and_operstate(struct l_netlink *rtnl, int ifindex,
+ uint8_t linkmode, uint8_t operstate,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+
+uint32_t l_rtnl_set_mac(struct l_netlink *rtnl, int ifindex,
+ const uint8_t addr[static 6],
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+
+uint32_t l_rtnl_set_powered(struct l_netlink *rtnl, int ifindex, bool powered,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy);
+
+void l_rtnl_ifaddr_extract(const struct ifaddrmsg *ifa, int bytes,
+ char **label, char **ip, char **broadcast);
+uint32_t l_rtnl_ifaddr_get(struct l_netlink *rtnl, l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_ifaddr_add(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ const char *broadcast,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_ifaddr_delete(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ const char *broadcast,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy);
+
+void l_rtnl_route_extract_ipv4(const struct rtmsg *rtmsg, uint32_t len,
+ uint32_t *ifindex, char **dst, char **gateway,
+ char **src);
+uint32_t l_rtnl_route_dump_ipv4(struct l_netlink *rtnl,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_route_ipv4_add_connected(struct l_netlink *rtnl, int ifindex,
+ uint8_t dst_len, const char *dst,
+ const char *src, uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_route_ipv4_add_gateway(struct l_netlink *rtnl, int ifindex,
+ const char *gateway, const char *src,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+
+void l_rtnl_ifaddr_ipv6_extract(const struct ifaddrmsg *ifa, int bytes,
+ char **ip);
+uint32_t l_rtnl_ifaddr_ipv6_get(struct l_netlink *rtnl,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_ifaddr_ipv6_add(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ l_netlink_command_func_t cb, void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_ifaddr_ipv6_delete(struct l_netlink *rtnl, int ifindex,
+ uint8_t prefix_len, const char *ip,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_route_ipv6_add_gateway(struct l_netlink *rtnl, int ifindex,
+ const char *gateway,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+uint32_t l_rtnl_route_ipv6_delete_gateway(struct l_netlink *rtnl, int ifindex,
+ const char *gateway,
+ uint32_t priority_offset,
+ uint8_t proto,
+ l_netlink_command_func_t cb,
+ void *user_data,
+ l_netlink_destroy_func_t destroy);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ELL_RTNL_H */
--
2.25.0
5:33 p.m.
New subject: [PATCH 2/2] unit: Add l_rtnl_* unit tests
Test the get and dump functions because these don't need special
permissions to run.
For testing the other functions we need first setup a test environment
so we don't disturb the hosts routing or IP configuration.
---
.gitignore | 1 +
Makefile.am | 3 +
unit/test-rtnl.c | 236 +++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 240 insertions(+)
create mode 100644 unit/test-rtnl.c
diff --git a/.gitignore b/.gitignore
index 372f0e7d3885..fca4b423678c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -32,6 +32,7 @@ unit/test-checksum
unit/test-settings
unit/test-netlink
unit/test-genl-msg
+unit/test-rtnl
unit/test-dbus
unit/test-dbus-message
unit/test-dbus-message-fds
diff --git a/Makefile.am b/Makefile.am
index 453f0d1b42d0..22b8f3daf5bb 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -167,6 +167,7 @@ unit_tests = unit/test-unit \
unit/test-settings \
unit/test-netlink \
unit/test-genl-msg \
+ unit/test-rtnl \
unit/test-siphash \
unit/test-cipher \
unit/test-random \
@@ -249,6 +250,8 @@ unit_test_netlink_LDADD = ell/libell-private.la
unit_test_genl_msg_LDADD = ell/libell-private.la
+unit_test_rtnl_LDADD = ell/libell-private.la
+
unit_test_dbus_LDADD = ell/libell-private.la
unit_test_dbus_message_LDADD = ell/libell-private.la
diff --git a/unit/test-rtnl.c b/unit/test-rtnl.c
new file mode 100644
index 000000000000..454d0529fe7f
--- /dev/null
+++ b/unit/test-rtnl.c
@@ -0,0 +1,236 @@
+/*
+ *
+ * Embedded Linux library
+ *
+ * Copyright (C) 2011-2014 Intel Corporation. All rights reserved.
+ * Copyright (C) 2020 Daniel Wagner <dwagner(a)suse.de>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/wait.h>
+
+#include <ell/ell.h>
+#include "ell/dbus-private.h"
+
+static void signal_handler(uint32_t signo, void *user_data)
+{
+ switch (signo) {
+ case SIGINT:
+ case SIGTERM:
+ l_info("Terminate");
+ l_main_quit();
+ break;
+ }
+}
+
+static struct l_netlink *rtnl;
+
+struct rtnl_test {
+ const char *name;
+ void (*start)(struct l_netlink *rtnl, void *);
+ void *data;
+};
+
+static bool success;
+static struct l_queue *tests;
+static const struct l_queue_entry *current;
+
+static void test_add(const char *name,
+ void (*start)(struct l_netlink *rtnl, void *),
+ void *user_data)
+{
+ struct rtnl_test *test = l_new(struct rtnl_test, 1);
+
+ test->name = name;
+ test->start = start;
+ test->data = user_data;
+
+ if (!tests)
+ tests = l_queue_new();
+
+ l_queue_push_tail(tests, test);
+}
+
+static void test_next()
+{
+ struct rtnl_test *test;
+
+ if (current)
+ current = current->next;
+ else
+ current = l_queue_get_entries(tests);
+
+ if (!current) {
+ success = true;
+ l_main_quit();
+ return;
+ }
+
+ test = current->data;
+
+ l_info("TEST: %s", test->name);
+
+ test->start(rtnl, test->data);
+}
+
+#define test_assert(cond) \
+ do { \
+ if (!(cond)) { \
+ l_info("TEST FAILED in %s at %s:%i: %s", \
+ __func__, __FILE__, __LINE__, \
+ L_STRINGIFY(cond)); \
+ l_main_quit(); \
+ return; \
+ } \
+ } while (0)
+
+
+static void route_dump_ipv4_cb(int error,
+ uint16_t type, const void *data,
+ uint32_t len, void *user_data)
+{
+ const struct rtmsg *rtmsg = data;
+ char *dst = NULL, *gateway = NULL, *src = NULL;
+ uint32_t idx;
+
+ test_assert(!error);
+ test_assert(type == RTM_NEWROUTE);
+
+ l_rtnl_route_extract_ipv4(rtmsg, len, &idx, &dst, &gateway, &src);
+
+ l_info("idx %d dst %s gateway %s src %s", idx, dst, gateway, src);
+
+ l_free(dst);
+ l_free(gateway);
+ l_free(src);
+}
+
+static void route_dump_ipv4_destroy_cb(void *user_data)
+{
+ test_next();
+}
+
+static void test_route_dump_ipv4(struct l_netlink *rtnl, void *user_data)
+{
+ test_assert(l_rtnl_route_dump_ipv4(rtnl, route_dump_ipv4_cb,
+ NULL, route_dump_ipv4_destroy_cb));
+}
+
+static void ifaddr_get_cb(int error,
+ uint16_t type, const void *data,
+ uint32_t len, void *user_data)
+{
+ const struct ifaddrmsg *ifa = data;
+ char *label = NULL, *ip = NULL, *broadcast = NULL;
+
+ test_assert(!error);
+ test_assert(type == RTM_NEWADDR);
+
+ l_rtnl_ifaddr_extract(ifa, len, &label, &ip, &broadcast);
+
+ l_info("label %s ip %s broadcast %s", label, ip, broadcast);
+
+ l_free(label);
+ l_free(ip);
+ l_free(broadcast);
+}
+
+static void ifaddr_get_destroy_cb(void *user_data)
+{
+ test_next();
+}
+
+static void test_ifaddr_get(struct l_netlink *rntl, void *user_data)
+{
+ test_assert(l_rtnl_ifaddr_get(rtnl, ifaddr_get_cb,
+ NULL, ifaddr_get_destroy_cb));
+}
+
+static void ifaddr_ipv6_get_cb(int error,
+ uint16_t type, const void *data,
+ uint32_t len, void *user_data)
+{
+ const struct ifaddrmsg *ifa = data;
+ char *ip = NULL;
+
+ test_assert(!error);
+ test_assert(type == RTM_NEWADDR);
+
+ l_rtnl_ifaddr_ipv6_extract(ifa, len, &ip);
+
+ l_info("ip %s", ip);
+
+ l_free(ip);
+}
+
+static void ifaddr_ipv6_get_destroy_cb(void *user_data)
+{
+ test_next();
+}
+
+static void test_ifaddr_ipv6_get(struct l_netlink *rntl, void *user_data)
+{
+ test_assert(l_rtnl_ifaddr_ipv6_get(rtnl, ifaddr_ipv6_get_cb,
+ NULL, ifaddr_ipv6_get_destroy_cb));
+}
+
+static void test_run(void)
+{
+ success = false;
+
+ l_idle_oneshot(test_next, NULL, NULL);
+ l_main_run_with_signal(signal_handler, NULL);
+}
+
+int main(int argc, char *argv[])
+{
+ if (!l_main_init())
+ return -1;
+
+ test_add("Dump IPv4 routing table", test_route_dump_ipv4, NULL);
+ test_add("Get IPv4 address", test_ifaddr_get, NULL);
+ test_add("Get IPv6 address", test_ifaddr_ipv6_get, NULL);
+
+ l_log_set_stderr();
+
+ rtnl = l_netlink_new(NETLINK_ROUTE);
+ if (!rtnl)
+ goto done;
+
+ test_run();
+
+ l_netlink_destroy(rtnl);
+
+done:
+ l_queue_destroy(tests, l_free);
+
+ l_main_exit();
+
+ if (!success)
+ abort();
+
+ return 0;
+}
--
2.25.0
6:53 p.m.
Hi Daniel,
On 2/14/20 10:33 AM, Daniel Wagner wrote:
This just copies over the code from iwd. No changes there except the
prefix of the functions name.
Unfortunatly, the unit test can only test the get/dump function
because the setters need root permissions. For this we need some sort
of sandbox. Does anyone have any ideas for this?
While writing the test case I noticed some inconsistency in the naming
sceme:
The IPv6 functions are consistent in the naming sceme, always
append ipv6 after the first name:
rtnl_ifaddr_ipv6_extract
rtnl_ifaddr_ipv6_get
rtnl_ifaddr_ipv6_add
rtnl_ifaddr_ipv6_delete
rtnl_route_ipv6_add_gateway
rtnl_route_ipv6_delete_gateway
For the IPv4 functions it's either a plain 'ifaddr' infix or somewhere ipv4
in the name:
rtnl_ifaddr_extract
rtnl_ifaddr_get
rtnl_ifaddr_add
rtnl_ifaddr_delete
rtnl_route_extract_ipv4
rtnl_route_dump_ipv4
-> drop ipv4?
rtnl_route_ipv4_add_connected
rtnl_route_ipv4_add_gateway
-> drop ipv4?
And there are the setters:
rtnl_set_linkmode_and_operstate
rtnl_set_mac
rtnl_set_powered
Is this the standard naming sceme?
Both applied. Now lets fix these up as discussed on IRC.
Regards,
-Denis
338
days inactive
338
days old
3 comments
2 participants
participants (2)
-
Daniel Wagner -
Denis Kenzior