mirror of
https://github.com/systemd/systemd.git
synced 2024-10-27 01:55:22 +03:00
sd-netlink: rename from sd-rtnl
This commit is contained in:
parent
eb59b60941
commit
1c4baffc18
4
.gitignore
vendored
4
.gitignore
vendored
@ -244,8 +244,8 @@
|
||||
/test-replace-var
|
||||
/test-resolve
|
||||
/test-ring
|
||||
/test-rtnl
|
||||
/test-rtnl-manual
|
||||
/test-netlink
|
||||
/test-netlink-manual
|
||||
/test-sched-prio
|
||||
/test-set
|
||||
/test-sigbus
|
||||
|
44
Makefile.am
44
Makefile.am
@ -233,7 +233,7 @@ AM_CPPFLAGS = \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-bus \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-event \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-login \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-rtnl \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-netlink \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-network \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-hwdb \
|
||||
-I $(top_srcdir)/src/libsystemd/sd-device \
|
||||
@ -1368,7 +1368,7 @@ endif
|
||||
|
||||
if HAVE_KMOD
|
||||
manual_tests += \
|
||||
test-rtnl-manual
|
||||
test-netlink-manual
|
||||
endif
|
||||
|
||||
tests += \
|
||||
@ -1873,14 +1873,14 @@ test_fw_util_LDADD = \
|
||||
$(LIBIPTC_LIBS)
|
||||
endif
|
||||
|
||||
test_rtnl_manual_SOURCES = \
|
||||
src/test/test-rtnl-manual.c
|
||||
test_netlink_manual_SOURCES = \
|
||||
src/test/test-netlink-manual.c
|
||||
|
||||
test_rtnl_manual_CFLAGS = \
|
||||
test_netlink_manual_CFLAGS = \
|
||||
$(AM_CFLAGS) \
|
||||
$(KMOD_CFLAGS)
|
||||
|
||||
test_rtnl_manual_LDADD = \
|
||||
test_netlink_manual_LDADD = \
|
||||
libshared.la \
|
||||
$(KMOD_LIBS)
|
||||
|
||||
@ -2856,7 +2856,7 @@ libsystemd_internal_la_SOURCES = \
|
||||
src/systemd/sd-bus-vtable.h \
|
||||
src/systemd/sd-utf8.h \
|
||||
src/systemd/sd-event.h \
|
||||
src/systemd/sd-rtnl.h \
|
||||
src/systemd/sd-netlink.h \
|
||||
src/systemd/sd-resolve.h \
|
||||
src/systemd/sd-login.h \
|
||||
src/systemd/sd-id128.h \
|
||||
@ -2910,15 +2910,15 @@ libsystemd_internal_la_SOURCES = \
|
||||
src/libsystemd/sd-utf8/sd-utf8.c \
|
||||
src/libsystemd/sd-event/sd-event.c \
|
||||
src/libsystemd/sd-event/event-util.h \
|
||||
src/libsystemd/sd-rtnl/sd-rtnl.c \
|
||||
src/libsystemd/sd-rtnl/rtnl-internal.h \
|
||||
src/libsystemd/sd-rtnl/rtnl-message.c \
|
||||
src/libsystemd/sd-rtnl/rtnl-types.h \
|
||||
src/libsystemd/sd-rtnl/rtnl-types.c \
|
||||
src/libsystemd/sd-rtnl/rtnl-util.h \
|
||||
src/libsystemd/sd-rtnl/rtnl-util.c \
|
||||
src/libsystemd/sd-rtnl/local-addresses.h \
|
||||
src/libsystemd/sd-rtnl/local-addresses.c \
|
||||
src/libsystemd/sd-netlink/sd-netlink.c \
|
||||
src/libsystemd/sd-netlink/netlink-internal.h \
|
||||
src/libsystemd/sd-netlink/netlink-message.c \
|
||||
src/libsystemd/sd-netlink/netlink-types.h \
|
||||
src/libsystemd/sd-netlink/netlink-types.c \
|
||||
src/libsystemd/sd-netlink/netlink-util.h \
|
||||
src/libsystemd/sd-netlink/netlink-util.c \
|
||||
src/libsystemd/sd-netlink/local-addresses.h \
|
||||
src/libsystemd/sd-netlink/local-addresses.c \
|
||||
src/libsystemd/sd-id128/sd-id128.c \
|
||||
src/libsystemd/sd-daemon/sd-daemon.c \
|
||||
src/libsystemd/sd-login/sd-login.c \
|
||||
@ -3019,7 +3019,7 @@ pkginclude_HEADERS += \
|
||||
if ENABLE_KDBUS
|
||||
pkginclude_HEADERS += \
|
||||
src/systemd/sd-utf8.h \
|
||||
src/systemd/sd-rtnl.h \
|
||||
src/systemd/sd-netlink.h \
|
||||
src/systemd/sd-resolve.h \
|
||||
src/systemd/sd-path.h
|
||||
endif
|
||||
@ -3044,7 +3044,7 @@ tests += \
|
||||
test-bus-creds \
|
||||
test-bus-gvariant \
|
||||
test-event \
|
||||
test-rtnl \
|
||||
test-netlink \
|
||||
test-local-addresses \
|
||||
test-resolve
|
||||
|
||||
@ -3175,14 +3175,14 @@ test_event_SOURCES = \
|
||||
test_event_LDADD = \
|
||||
libshared.la
|
||||
|
||||
test_rtnl_SOURCES = \
|
||||
src/libsystemd/sd-rtnl/test-rtnl.c
|
||||
test_netlink_SOURCES = \
|
||||
src/libsystemd/sd-netlink/test-netlink.c
|
||||
|
||||
test_rtnl_LDADD = \
|
||||
test_netlink_LDADD = \
|
||||
libshared.la
|
||||
|
||||
test_local_addresses_SOURCES = \
|
||||
src/libsystemd/sd-rtnl/test-local-addresses.c
|
||||
src/libsystemd/sd-netlink/test-local-addresses.c
|
||||
|
||||
test_local_addresses_LDADD = \
|
||||
libshared.la
|
||||
|
@ -22,13 +22,13 @@
|
||||
#include <net/if.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "netlink-util.h"
|
||||
#include "missing.h"
|
||||
#include "loopback-setup.h"
|
||||
|
||||
static int start_loopback(sd_rtnl *rtnl) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
static int start_loopback(sd_netlink *rtnl) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
r = sd_rtnl_message_new_link(rtnl, &req, RTM_SETLINK, LOOPBACK_IFINDEX);
|
||||
@ -39,15 +39,15 @@ static int start_loopback(sd_rtnl *rtnl) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, NULL);
|
||||
r = sd_netlink_call(rtnl, req, 0, NULL);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool check_loopback(sd_rtnl *rtnl) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
static bool check_loopback(sd_netlink *rtnl) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
unsigned flags;
|
||||
int r;
|
||||
|
||||
@ -55,7 +55,7 @@ static bool check_loopback(sd_rtnl *rtnl) {
|
||||
if (r < 0)
|
||||
return false;
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return false;
|
||||
|
||||
@ -67,10 +67,10 @@ static bool check_loopback(sd_rtnl *rtnl) {
|
||||
}
|
||||
|
||||
int loopback_setup(void) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
int r;
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
|
@ -29,7 +29,7 @@
|
||||
#include "util.h"
|
||||
#include "sd-event.h"
|
||||
#include "event-util.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "sd-pppoe.h"
|
||||
#include "process-util.h"
|
||||
|
||||
@ -83,8 +83,8 @@ static int client_run(const char *client_name, sd_event *e) {
|
||||
}
|
||||
|
||||
static int test_pppoe_server(sd_event *e) {
|
||||
sd_rtnl *rtnl;
|
||||
sd_rtnl_message *m;
|
||||
sd_netlink *rtnl;
|
||||
sd_netlink_message *m;
|
||||
pid_t pid;
|
||||
int r, client_ifindex, server_ifindex;
|
||||
|
||||
@ -94,34 +94,34 @@ static int test_pppoe_server(sd_event *e) {
|
||||
|
||||
assert_se(r >= 0);
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
assert_se(sd_rtnl_attach_event(rtnl, e, 0) >= 0);
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
assert_se(sd_netlink_attach_event(rtnl, e, 0) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0) >= 0);
|
||||
assert_se(sd_rtnl_message_append_string(m, IFLA_IFNAME, "pppoe-server") >= 0);
|
||||
assert_se(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "veth") >= 0);
|
||||
assert_se(sd_rtnl_message_open_container(m, VETH_INFO_PEER) >= 0);
|
||||
assert_se(sd_rtnl_message_append_string(m, IFLA_IFNAME, "pppoe-client") >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_rtnl_call(rtnl, m, 0, NULL) >= 0);
|
||||
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, "pppoe-server") >= 0);
|
||||
assert_se(sd_netlink_message_open_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "veth") >= 0);
|
||||
assert_se(sd_netlink_message_open_container(m, VETH_INFO_PEER) >= 0);
|
||||
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, "pppoe-client") >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_call(rtnl, m, 0, NULL) >= 0);
|
||||
|
||||
client_ifindex = (int) if_nametoindex("pppoe-client");
|
||||
assert_se(client_ifindex > 0);
|
||||
server_ifindex = (int) if_nametoindex("pppoe-server");
|
||||
assert_se(server_ifindex > 0);
|
||||
|
||||
m = sd_rtnl_message_unref(m);
|
||||
m = sd_netlink_message_unref(m);
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, client_ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_link_set_flags(m, IFF_UP, IFF_UP) >= 0);
|
||||
assert_se(sd_rtnl_call(rtnl, m, 0, NULL) >= 0);
|
||||
assert_se(sd_netlink_call(rtnl, m, 0, NULL) >= 0);
|
||||
|
||||
m = sd_rtnl_message_unref(m);
|
||||
m = sd_netlink_message_unref(m);
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, server_ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_link_set_flags(m, IFF_UP, IFF_UP) >= 0);
|
||||
assert_se(sd_rtnl_call(rtnl, m, 0, NULL) >= 0);
|
||||
assert_se(sd_netlink_call(rtnl, m, 0, NULL) >= 0);
|
||||
|
||||
pid = fork();
|
||||
assert_se(pid >= 0);
|
||||
@ -145,8 +145,8 @@ static int test_pppoe_server(sd_event *e) {
|
||||
assert_se(kill(pid, SIGTERM) >= 0);
|
||||
assert_se(wait_for_terminate(pid, NULL) >= 0);
|
||||
|
||||
assert_se(!sd_rtnl_message_unref(m));
|
||||
assert_se(!sd_rtnl_unref(rtnl));
|
||||
assert_se(!sd_netlink_message_unref(m));
|
||||
assert_se(!sd_netlink_unref(rtnl));
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
@ -20,8 +20,8 @@
|
||||
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
||||
***/
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "netlink-util.h"
|
||||
#include "macro.h"
|
||||
#include "local-addresses.h"
|
||||
|
||||
@ -53,20 +53,20 @@ static int address_compare(const void *_a, const void *_b) {
|
||||
return memcmp(&a->address, &b->address, FAMILY_ADDRESS_SIZE(a->family));
|
||||
}
|
||||
|
||||
int local_addresses(sd_rtnl *context, int ifindex, int af, struct local_address **ret) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
int local_addresses(sd_netlink *context, int ifindex, int af, struct local_address **ret) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_free_ struct local_address *list = NULL;
|
||||
size_t n_list = 0, n_allocated = 0;
|
||||
sd_rtnl_message *m;
|
||||
sd_netlink_message *m;
|
||||
int r;
|
||||
|
||||
assert(ret);
|
||||
|
||||
if (context)
|
||||
rtnl = sd_rtnl_ref(context);
|
||||
rtnl = sd_netlink_ref(context);
|
||||
else {
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
@ -75,21 +75,21 @@ int local_addresses(sd_rtnl *context, int ifindex, int af, struct local_address
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (m = reply; m; m = sd_rtnl_message_next(m)) {
|
||||
for (m = reply; m; m = sd_netlink_message_next(m)) {
|
||||
struct local_address *a;
|
||||
unsigned char flags;
|
||||
uint16_t type;
|
||||
int ifi, family;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_get_type(m, &type);
|
||||
r = sd_netlink_message_get_type(m, &type);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (type != RTM_NEWADDR)
|
||||
@ -128,18 +128,18 @@ int local_addresses(sd_rtnl *context, int ifindex, int af, struct local_address
|
||||
switch (family) {
|
||||
|
||||
case AF_INET:
|
||||
r = sd_rtnl_message_read_in_addr(m, IFA_LOCAL, &a->address.in);
|
||||
r = sd_netlink_message_read_in_addr(m, IFA_LOCAL, &a->address.in);
|
||||
if (r < 0) {
|
||||
r = sd_rtnl_message_read_in_addr(m, IFA_ADDRESS, &a->address.in);
|
||||
r = sd_netlink_message_read_in_addr(m, IFA_ADDRESS, &a->address.in);
|
||||
if (r < 0)
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
|
||||
case AF_INET6:
|
||||
r = sd_rtnl_message_read_in6_addr(m, IFA_LOCAL, &a->address.in6);
|
||||
r = sd_netlink_message_read_in6_addr(m, IFA_LOCAL, &a->address.in6);
|
||||
if (r < 0) {
|
||||
r = sd_rtnl_message_read_in6_addr(m, IFA_ADDRESS, &a->address.in6);
|
||||
r = sd_netlink_message_read_in6_addr(m, IFA_ADDRESS, &a->address.in6);
|
||||
if (r < 0)
|
||||
continue;
|
||||
}
|
||||
@ -164,20 +164,20 @@ int local_addresses(sd_rtnl *context, int ifindex, int af, struct local_address
|
||||
return (int) n_list;
|
||||
}
|
||||
|
||||
int local_gateways(sd_rtnl *context, int ifindex, int af, struct local_address **ret) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
int local_gateways(sd_netlink *context, int ifindex, int af, struct local_address **ret) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_free_ struct local_address *list = NULL;
|
||||
sd_rtnl_message *m = NULL;
|
||||
sd_netlink_message *m = NULL;
|
||||
size_t n_list = 0, n_allocated = 0;
|
||||
int r;
|
||||
|
||||
assert(ret);
|
||||
|
||||
if (context)
|
||||
rtnl = sd_rtnl_ref(context);
|
||||
rtnl = sd_netlink_ref(context);
|
||||
else {
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
@ -186,26 +186,26 @@ int local_gateways(sd_rtnl *context, int ifindex, int af, struct local_address *
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (m = reply; m; m = sd_rtnl_message_next(m)) {
|
||||
for (m = reply; m; m = sd_netlink_message_next(m)) {
|
||||
struct local_address *a;
|
||||
uint16_t type;
|
||||
unsigned char dst_len, src_len;
|
||||
uint32_t ifi;
|
||||
int family;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_get_type(m, &type);
|
||||
r = sd_netlink_message_get_type(m, &type);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (type != RTM_NEWROUTE)
|
||||
@ -224,7 +224,7 @@ int local_gateways(sd_rtnl *context, int ifindex, int af, struct local_address *
|
||||
if (src_len != 0)
|
||||
continue;
|
||||
|
||||
r = sd_rtnl_message_read_u32(m, RTA_OIF, &ifi);
|
||||
r = sd_netlink_message_read_u32(m, RTA_OIF, &ifi);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (ifindex > 0 && (int) ifi != ifindex)
|
||||
@ -243,13 +243,13 @@ int local_gateways(sd_rtnl *context, int ifindex, int af, struct local_address *
|
||||
|
||||
switch (family) {
|
||||
case AF_INET:
|
||||
r = sd_rtnl_message_read_in_addr(m, RTA_GATEWAY, &a->address.in);
|
||||
r = sd_netlink_message_read_in_addr(m, RTA_GATEWAY, &a->address.in);
|
||||
if (r < 0)
|
||||
continue;
|
||||
|
||||
break;
|
||||
case AF_INET6:
|
||||
r = sd_rtnl_message_read_in6_addr(m, RTA_GATEWAY, &a->address.in6);
|
||||
r = sd_netlink_message_read_in6_addr(m, RTA_GATEWAY, &a->address.in6);
|
||||
if (r < 0)
|
||||
continue;
|
||||
|
||||
@ -258,7 +258,7 @@ int local_gateways(sd_rtnl *context, int ifindex, int af, struct local_address *
|
||||
continue;
|
||||
}
|
||||
|
||||
sd_rtnl_message_read_u32(m, RTA_PRIORITY, &a->metric);
|
||||
sd_netlink_message_read_u32(m, RTA_PRIORITY, &a->metric);
|
||||
|
||||
a->ifindex = ifi;
|
||||
a->family = family;
|
@ -22,7 +22,7 @@
|
||||
***/
|
||||
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "in-addr-util.h"
|
||||
|
||||
struct local_address {
|
||||
@ -32,6 +32,6 @@ struct local_address {
|
||||
union in_addr_union address;
|
||||
};
|
||||
|
||||
int local_addresses(sd_rtnl *rtnl, int ifindex, int af, struct local_address **ret);
|
||||
int local_addresses(sd_netlink *rtnl, int ifindex, int af, struct local_address **ret);
|
||||
|
||||
int local_gateways(sd_rtnl *rtnl, int ifindex, int af, struct local_address **ret);
|
||||
int local_gateways(sd_netlink *rtnl, int ifindex, int af, struct local_address **ret);
|
@ -27,9 +27,9 @@
|
||||
#include "prioq.h"
|
||||
#include "list.h"
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
|
||||
#include "rtnl-types.h"
|
||||
#include "netlink-types.h"
|
||||
|
||||
#define RTNL_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
#define RTNL_CONTAINER_DEPTH 32
|
||||
|
||||
struct reply_callback {
|
||||
sd_rtnl_message_handler_t callback;
|
||||
sd_netlink_message_handler_t callback;
|
||||
void *userdata;
|
||||
usec_t timeout;
|
||||
uint64_t serial;
|
||||
@ -47,14 +47,14 @@ struct reply_callback {
|
||||
};
|
||||
|
||||
struct match_callback {
|
||||
sd_rtnl_message_handler_t callback;
|
||||
sd_netlink_message_handler_t callback;
|
||||
uint16_t type;
|
||||
void *userdata;
|
||||
|
||||
LIST_FIELDS(struct match_callback, match_callbacks);
|
||||
};
|
||||
|
||||
struct sd_rtnl {
|
||||
struct sd_netlink {
|
||||
RefCount n_ref;
|
||||
|
||||
int fd;
|
||||
@ -64,15 +64,15 @@ struct sd_rtnl {
|
||||
struct sockaddr_nl nl;
|
||||
} sockaddr;
|
||||
|
||||
sd_rtnl_message **rqueue;
|
||||
sd_netlink_message **rqueue;
|
||||
unsigned rqueue_size;
|
||||
size_t rqueue_allocated;
|
||||
|
||||
sd_rtnl_message **rqueue_partial;
|
||||
sd_netlink_message **rqueue_partial;
|
||||
unsigned rqueue_partial_size;
|
||||
size_t rqueue_partial_allocated;
|
||||
|
||||
sd_rtnl_message **wqueue;
|
||||
sd_netlink_message **wqueue;
|
||||
unsigned wqueue_size;
|
||||
size_t wqueue_allocated;
|
||||
|
||||
@ -96,10 +96,10 @@ struct sd_rtnl {
|
||||
sd_event *event;
|
||||
};
|
||||
|
||||
struct sd_rtnl_message {
|
||||
struct sd_netlink_message {
|
||||
RefCount n_ref;
|
||||
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
|
||||
struct nlmsghdr *hdr;
|
||||
const struct NLTypeSystem *(container_type_system[RTNL_CONTAINER_DEPTH]); /* the type of the container and all its parents */
|
||||
@ -111,19 +111,19 @@ struct sd_rtnl_message {
|
||||
bool sealed:1;
|
||||
bool broadcast:1;
|
||||
|
||||
sd_rtnl_message *next; /* next in a chain of multi-part messages */
|
||||
sd_netlink_message *next; /* next in a chain of multi-part messages */
|
||||
};
|
||||
|
||||
int message_new(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t type);
|
||||
int message_new(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t type);
|
||||
|
||||
int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m);
|
||||
int socket_read_message(sd_rtnl *nl);
|
||||
int socket_write_message(sd_netlink *nl, sd_netlink_message *m);
|
||||
int socket_read_message(sd_netlink *nl);
|
||||
|
||||
int rtnl_rqueue_make_room(sd_rtnl *rtnl);
|
||||
int rtnl_rqueue_partial_make_room(sd_rtnl *rtnl);
|
||||
int rtnl_rqueue_make_room(sd_netlink *rtnl);
|
||||
int rtnl_rqueue_partial_make_room(sd_netlink *rtnl);
|
||||
|
||||
int rtnl_message_read_internal(sd_rtnl_message *m, unsigned short type, void **data);
|
||||
int rtnl_message_parse(sd_rtnl_message *m,
|
||||
int rtnl_message_read_internal(sd_netlink_message *m, unsigned short type, void **data);
|
||||
int rtnl_message_parse(sd_netlink_message *m,
|
||||
size_t **rta_offset_tb,
|
||||
unsigned short *rta_tb_size,
|
||||
int max,
|
||||
@ -132,4 +132,4 @@ int rtnl_message_parse(sd_rtnl_message *m,
|
||||
|
||||
/* Make sure callbacks don't destroy the rtnl connection */
|
||||
#define RTNL_DONT_DESTROY(rtnl) \
|
||||
_cleanup_rtnl_unref_ _unused_ sd_rtnl *_dont_destroy_##rtnl = sd_rtnl_ref(rtnl)
|
||||
_cleanup_netlink_unref_ _unused_ sd_netlink *_dont_destroy_##rtnl = sd_netlink_ref(rtnl)
|
@ -29,18 +29,18 @@
|
||||
#include "refcnt.h"
|
||||
#include "missing.h"
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "rtnl-internal.h"
|
||||
#include "rtnl-types.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "netlink-util.h"
|
||||
#include "netlink-internal.h"
|
||||
#include "netlink-types.h"
|
||||
|
||||
#define GET_CONTAINER(m, i) ((i) < (m)->n_containers ? (struct rtattr*)((uint8_t*)(m)->hdr + (m)->container_offsets[i]) : NULL)
|
||||
#define PUSH_CONTAINER(m, new) (m)->container_offsets[(m)->n_containers ++] = (uint8_t*)(new) - (uint8_t*)(m)->hdr;
|
||||
|
||||
#define RTA_TYPE(rta) ((rta)->rta_type & NLA_TYPE_MASK)
|
||||
|
||||
static int message_new_empty(sd_rtnl *rtnl, sd_rtnl_message **ret) {
|
||||
sd_rtnl_message *m;
|
||||
static int message_new_empty(sd_netlink *rtnl, sd_netlink_message **ret) {
|
||||
sd_netlink_message *m;
|
||||
|
||||
assert_return(ret, -EINVAL);
|
||||
|
||||
@ -49,7 +49,7 @@ static int message_new_empty(sd_rtnl *rtnl, sd_rtnl_message **ret) {
|
||||
buses and their queued messages. See sd-bus.
|
||||
*/
|
||||
|
||||
m = new0(sd_rtnl_message, 1);
|
||||
m = new0(sd_netlink_message, 1);
|
||||
if (!m)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -62,8 +62,8 @@ static int message_new_empty(sd_rtnl *rtnl, sd_rtnl_message **ret) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int message_new(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t type) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
int message_new(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t type) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
const NLType *nl_type;
|
||||
size_t size;
|
||||
int r;
|
||||
@ -95,7 +95,7 @@ int message_new(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t type) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_route_set_dst_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
|
||||
int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
|
||||
struct rtmsg *rtm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -113,7 +113,7 @@ int sd_rtnl_message_route_set_dst_prefixlen(sd_rtnl_message *m, unsigned char pr
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_route_set_src_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
|
||||
int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
|
||||
struct rtmsg *rtm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -131,7 +131,7 @@ int sd_rtnl_message_route_set_src_prefixlen(sd_rtnl_message *m, unsigned char pr
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_route_set_scope(sd_rtnl_message *m, unsigned char scope) {
|
||||
int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope) {
|
||||
struct rtmsg *rtm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -145,7 +145,7 @@ int sd_rtnl_message_route_set_scope(sd_rtnl_message *m, unsigned char scope) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_route_get_family(sd_rtnl_message *m, int *family) {
|
||||
int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family) {
|
||||
struct rtmsg *rtm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -160,7 +160,7 @@ int sd_rtnl_message_route_get_family(sd_rtnl_message *m, int *family) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_route_get_dst_prefixlen(sd_rtnl_message *m, unsigned char *dst_len) {
|
||||
int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len) {
|
||||
struct rtmsg *rtm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -175,7 +175,7 @@ int sd_rtnl_message_route_get_dst_prefixlen(sd_rtnl_message *m, unsigned char *d
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_route_get_src_prefixlen(sd_rtnl_message *m, unsigned char *src_len) {
|
||||
int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len) {
|
||||
struct rtmsg *rtm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -190,7 +190,7 @@ int sd_rtnl_message_route_get_src_prefixlen(sd_rtnl_message *m, unsigned char *s
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret,
|
||||
uint16_t nlmsg_type, int rtm_family,
|
||||
unsigned char rtm_protocol) {
|
||||
struct rtmsg *rtm;
|
||||
@ -219,7 +219,7 @@ int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_neigh_set_flags(sd_rtnl_message *m, uint8_t flags) {
|
||||
int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags) {
|
||||
struct ndmsg *ndm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -232,7 +232,7 @@ int sd_rtnl_message_neigh_set_flags(sd_rtnl_message *m, uint8_t flags) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_neigh_set_state(sd_rtnl_message *m, uint16_t state) {
|
||||
int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state) {
|
||||
struct ndmsg *ndm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -245,7 +245,7 @@ int sd_rtnl_message_neigh_set_state(sd_rtnl_message *m, uint16_t state) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_neigh_get_flags(sd_rtnl_message *m, uint8_t *flags) {
|
||||
int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags) {
|
||||
struct ndmsg *ndm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -258,7 +258,7 @@ int sd_rtnl_message_neigh_get_flags(sd_rtnl_message *m, uint8_t *flags) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_neigh_get_state(sd_rtnl_message *m, uint16_t *state) {
|
||||
int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state) {
|
||||
struct ndmsg *ndm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -271,7 +271,7 @@ int sd_rtnl_message_neigh_get_state(sd_rtnl_message *m, uint16_t *state) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_neigh_get_family(sd_rtnl_message *m, int *family) {
|
||||
int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family) {
|
||||
struct ndmsg *ndm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -286,7 +286,7 @@ int sd_rtnl_message_neigh_get_family(sd_rtnl_message *m, int *family) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_neigh_get_ifindex(sd_rtnl_message *m, int *index) {
|
||||
int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *index) {
|
||||
struct ndmsg *ndm;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -301,7 +301,7 @@ int sd_rtnl_message_neigh_get_ifindex(sd_rtnl_message *m, int *index) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_new_neigh(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t nlmsg_type, int index, int ndm_family) {
|
||||
int sd_rtnl_message_new_neigh(sd_netlink *rtnl, sd_netlink_message **ret, uint16_t nlmsg_type, int index, int ndm_family) {
|
||||
struct ndmsg *ndm;
|
||||
int r;
|
||||
|
||||
@ -326,7 +326,7 @@ int sd_rtnl_message_new_neigh(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t nlm
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags, unsigned change) {
|
||||
int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change) {
|
||||
struct ifinfomsg *ifi;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -342,7 +342,7 @@ int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags, unsigned
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_link_set_type(sd_rtnl_message *m, unsigned type) {
|
||||
int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type) {
|
||||
struct ifinfomsg *ifi;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -356,7 +356,7 @@ int sd_rtnl_message_link_set_type(sd_rtnl_message *m, unsigned type) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_link_set_family(sd_rtnl_message *m, unsigned family) {
|
||||
int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family) {
|
||||
struct ifinfomsg *ifi;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -370,7 +370,7 @@ int sd_rtnl_message_link_set_family(sd_rtnl_message *m, unsigned family) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
int sd_rtnl_message_new_link(sd_netlink *rtnl, sd_netlink_message **ret,
|
||||
uint16_t nlmsg_type, int index) {
|
||||
struct ifinfomsg *ifi;
|
||||
int r;
|
||||
@ -394,7 +394,7 @@ int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_request_dump(sd_rtnl_message *m, int dump) {
|
||||
int sd_netlink_message_request_dump(sd_netlink_message *m, int dump) {
|
||||
assert_return(m, -EINVAL);
|
||||
assert_return(m->hdr, -EINVAL);
|
||||
assert_return(m->hdr->nlmsg_type == RTM_GETLINK ||
|
||||
@ -411,7 +411,7 @@ int sd_rtnl_message_request_dump(sd_rtnl_message *m, int dump) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_set_prefixlen(sd_rtnl_message *m, unsigned char prefixlen) {
|
||||
int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -429,7 +429,7 @@ int sd_rtnl_message_addr_set_prefixlen(sd_rtnl_message *m, unsigned char prefixl
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_set_flags(sd_rtnl_message *m, unsigned char flags) {
|
||||
int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -443,7 +443,7 @@ int sd_rtnl_message_addr_set_flags(sd_rtnl_message *m, unsigned char flags) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_set_scope(sd_rtnl_message *m, unsigned char scope) {
|
||||
int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -457,7 +457,7 @@ int sd_rtnl_message_addr_set_scope(sd_rtnl_message *m, unsigned char scope) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_get_family(sd_rtnl_message *m, int *family) {
|
||||
int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -472,7 +472,7 @@ int sd_rtnl_message_addr_get_family(sd_rtnl_message *m, int *family) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_get_prefixlen(sd_rtnl_message *m, unsigned char *prefixlen) {
|
||||
int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -487,7 +487,7 @@ int sd_rtnl_message_addr_get_prefixlen(sd_rtnl_message *m, unsigned char *prefix
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_get_scope(sd_rtnl_message *m, unsigned char *scope) {
|
||||
int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -502,7 +502,7 @@ int sd_rtnl_message_addr_get_scope(sd_rtnl_message *m, unsigned char *scope) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_get_flags(sd_rtnl_message *m, unsigned char *flags) {
|
||||
int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -517,7 +517,7 @@ int sd_rtnl_message_addr_get_flags(sd_rtnl_message *m, unsigned char *flags) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_addr_get_ifindex(sd_rtnl_message *m, int *ifindex) {
|
||||
int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex) {
|
||||
struct ifaddrmsg *ifa;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -532,7 +532,7 @@ int sd_rtnl_message_addr_get_ifindex(sd_rtnl_message *m, int *ifindex) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret,
|
||||
uint16_t nlmsg_type, int index,
|
||||
int family) {
|
||||
struct ifaddrmsg *ifa;
|
||||
@ -564,7 +564,7 @@ int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_new_addr_update(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
int sd_rtnl_message_new_addr_update(sd_netlink *rtnl, sd_netlink_message **ret,
|
||||
int index, int family) {
|
||||
int r;
|
||||
|
||||
@ -577,14 +577,14 @@ int sd_rtnl_message_new_addr_update(sd_rtnl *rtnl, sd_rtnl_message **ret,
|
||||
return 0;
|
||||
}
|
||||
|
||||
sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m) {
|
||||
sd_netlink_message *sd_netlink_message_ref(sd_netlink_message *m) {
|
||||
if (m)
|
||||
assert_se(REFCNT_INC(m->n_ref) >= 2);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) {
|
||||
sd_netlink_message *sd_netlink_message_unref(sd_netlink_message *m) {
|
||||
if (m && REFCNT_DEC(m->n_ref) == 0) {
|
||||
unsigned i;
|
||||
|
||||
@ -593,7 +593,7 @@ sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) {
|
||||
for (i = 0; i <= m->n_containers; i++)
|
||||
free(m->rta_offset_tb[i]);
|
||||
|
||||
sd_rtnl_message_unref(m->next);
|
||||
sd_netlink_message_unref(m->next);
|
||||
|
||||
free(m);
|
||||
}
|
||||
@ -601,7 +601,7 @@ sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) {
|
||||
int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type) {
|
||||
assert_return(m, -EINVAL);
|
||||
assert_return(type, -EINVAL);
|
||||
|
||||
@ -610,7 +610,7 @@ int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_get_family(sd_rtnl_message *m, int *family) {
|
||||
int sd_netlink_message_get_family(sd_netlink_message *m, int *family) {
|
||||
assert_return(m, -EINVAL);
|
||||
assert_return(family, -EINVAL);
|
||||
|
||||
@ -653,13 +653,13 @@ int sd_rtnl_message_get_family(sd_rtnl_message *m, int *family) {
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_is_broadcast(sd_rtnl_message *m) {
|
||||
int sd_netlink_message_is_broadcast(sd_netlink_message *m) {
|
||||
assert_return(m, -EINVAL);
|
||||
|
||||
return m->broadcast;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) {
|
||||
int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex) {
|
||||
struct ifinfomsg *ifi;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -674,7 +674,7 @@ int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_link_get_flags(sd_rtnl_message *m, unsigned *flags) {
|
||||
int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags) {
|
||||
struct ifinfomsg *ifi;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -689,7 +689,7 @@ int sd_rtnl_message_link_get_flags(sd_rtnl_message *m, unsigned *flags) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_link_get_type(sd_rtnl_message *m, unsigned *type) {
|
||||
int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned *type) {
|
||||
struct ifinfomsg *ifi;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -706,7 +706,7 @@ int sd_rtnl_message_link_get_type(sd_rtnl_message *m, unsigned *type) {
|
||||
|
||||
/* If successful the updated message will be correctly aligned, if
|
||||
unsuccessful the old message is untouched. */
|
||||
static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data, size_t data_length) {
|
||||
static int add_rtattr(sd_netlink_message *m, unsigned short type, const void *data, size_t data_length) {
|
||||
uint32_t rta_length;
|
||||
size_t message_length, padding_length;
|
||||
struct nlmsghdr *new_hdr;
|
||||
@ -767,7 +767,7 @@ static int add_rtattr(sd_rtnl_message *m, unsigned short type, const void *data,
|
||||
return offset;
|
||||
}
|
||||
|
||||
static int message_attribute_has_type(sd_rtnl_message *m, uint16_t attribute_type, uint16_t data_type) {
|
||||
static int message_attribute_has_type(sd_netlink_message *m, uint16_t attribute_type, uint16_t data_type) {
|
||||
const NLType *type;
|
||||
int r;
|
||||
|
||||
@ -781,7 +781,7 @@ static int message_attribute_has_type(sd_rtnl_message *m, uint16_t attribute_typ
|
||||
return type->size;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const char *data) {
|
||||
int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data) {
|
||||
size_t length, size;
|
||||
int r;
|
||||
|
||||
@ -809,7 +809,7 @@ int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_u8(sd_rtnl_message *m, unsigned short type, uint8_t data) {
|
||||
int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -827,7 +827,7 @@ int sd_rtnl_message_append_u8(sd_rtnl_message *m, unsigned short type, uint8_t d
|
||||
}
|
||||
|
||||
|
||||
int sd_rtnl_message_append_u16(sd_rtnl_message *m, unsigned short type, uint16_t data) {
|
||||
int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -844,7 +844,7 @@ int sd_rtnl_message_append_u16(sd_rtnl_message *m, unsigned short type, uint16_t
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t data) {
|
||||
int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -861,7 +861,7 @@ int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, const struct in_addr *data) {
|
||||
int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -879,7 +879,7 @@ int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, cons
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, const struct in6_addr *data) {
|
||||
int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -897,7 +897,7 @@ int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, con
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, const struct ether_addr *data) {
|
||||
int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -915,7 +915,7 @@ int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, c
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_append_cache_info(sd_rtnl_message *m, unsigned short type, const struct ifa_cacheinfo *info) {
|
||||
int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info) {
|
||||
int r;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -933,7 +933,7 @@ int sd_rtnl_message_append_cache_info(sd_rtnl_message *m, unsigned short type, c
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) {
|
||||
int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type) {
|
||||
size_t size;
|
||||
int r;
|
||||
|
||||
@ -951,7 +951,7 @@ int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) {
|
||||
return r;
|
||||
size = (size_t) r;
|
||||
|
||||
r = sd_rtnl_message_get_family(m, &family);
|
||||
r = sd_netlink_message_get_family(m, &family);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -983,7 +983,7 @@ int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_open_container_union(sd_rtnl_message *m, unsigned short type, const char *key) {
|
||||
int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key) {
|
||||
const NLTypeSystemUnion *type_system_union;
|
||||
int r;
|
||||
|
||||
@ -1000,7 +1000,7 @@ int sd_rtnl_message_open_container_union(sd_rtnl_message *m, unsigned short type
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_append_string(m, type_system_union->match, key);
|
||||
r = sd_netlink_message_append_string(m, type_system_union->match, key);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -1015,7 +1015,7 @@ int sd_rtnl_message_open_container_union(sd_rtnl_message *m, unsigned short type
|
||||
}
|
||||
|
||||
|
||||
int sd_rtnl_message_close_container(sd_rtnl_message *m) {
|
||||
int sd_netlink_message_close_container(sd_netlink_message *m) {
|
||||
assert_return(m, -EINVAL);
|
||||
assert_return(!m->sealed, -EPERM);
|
||||
assert_return(m->n_containers > 0, -EINVAL);
|
||||
@ -1026,7 +1026,7 @@ int sd_rtnl_message_close_container(sd_rtnl_message *m) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int rtnl_message_read_internal(sd_rtnl_message *m, unsigned short type, void **data) {
|
||||
int rtnl_message_read_internal(sd_netlink_message *m, unsigned short type, void **data) {
|
||||
struct rtattr *rta;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
@ -1046,7 +1046,7 @@ int rtnl_message_read_internal(sd_rtnl_message *m, unsigned short type, void **d
|
||||
return RTA_PAYLOAD(rta);
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_string(sd_rtnl_message *m, unsigned short type, const char **data) {
|
||||
int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1068,7 +1068,7 @@ int sd_rtnl_message_read_string(sd_rtnl_message *m, unsigned short type, const c
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_u8(sd_rtnl_message *m, unsigned short type, uint8_t *data) {
|
||||
int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1090,7 +1090,7 @@ int sd_rtnl_message_read_u8(sd_rtnl_message *m, unsigned short type, uint8_t *da
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_u16(sd_rtnl_message *m, unsigned short type, uint16_t *data) {
|
||||
int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1112,7 +1112,7 @@ int sd_rtnl_message_read_u16(sd_rtnl_message *m, unsigned short type, uint16_t *
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_u32(sd_rtnl_message *m, unsigned short type, uint32_t *data) {
|
||||
int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1134,7 +1134,7 @@ int sd_rtnl_message_read_u32(sd_rtnl_message *m, unsigned short type, uint32_t *
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_ether_addr(sd_rtnl_message *m, unsigned short type, struct ether_addr *data) {
|
||||
int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1156,7 +1156,7 @@ int sd_rtnl_message_read_ether_addr(sd_rtnl_message *m, unsigned short type, str
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_cache_info(sd_rtnl_message *m, unsigned short type, struct ifa_cacheinfo *info) {
|
||||
int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1178,7 +1178,7 @@ int sd_rtnl_message_read_cache_info(sd_rtnl_message *m, unsigned short type, str
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_in_addr(sd_rtnl_message *m, unsigned short type, struct in_addr *data) {
|
||||
int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1200,7 +1200,7 @@ int sd_rtnl_message_read_in_addr(sd_rtnl_message *m, unsigned short type, struct
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_read_in6_addr(sd_rtnl_message *m, unsigned short type, struct in6_addr *data) {
|
||||
int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data) {
|
||||
int r;
|
||||
void *attr_data;
|
||||
|
||||
@ -1222,7 +1222,7 @@ int sd_rtnl_message_read_in6_addr(sd_rtnl_message *m, unsigned short type, struc
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
|
||||
int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type) {
|
||||
const NLType *nl_type;
|
||||
const NLTypeSystem *type_system;
|
||||
void *container;
|
||||
@ -1258,7 +1258,7 @@ int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
|
||||
{
|
||||
const char *key;
|
||||
|
||||
r = sd_rtnl_message_read_string(m, type_system_union->match, &key);
|
||||
r = sd_netlink_message_read_string(m, type_system_union->match, &key);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -1274,7 +1274,7 @@ int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
|
||||
{
|
||||
int family;
|
||||
|
||||
r = sd_rtnl_message_get_family(m, &family);
|
||||
r = sd_netlink_message_get_family(m, &family);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -1287,7 +1287,7 @@ int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
|
||||
break;
|
||||
}
|
||||
default:
|
||||
assert_not_reached("sd-rtnl: invalid type system union type");
|
||||
assert_not_reached("sd-netlink: invalid type system union type");
|
||||
}
|
||||
} else
|
||||
return -EINVAL;
|
||||
@ -1316,7 +1316,7 @@ int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_exit_container(sd_rtnl_message *m) {
|
||||
int sd_netlink_message_exit_container(sd_netlink_message *m) {
|
||||
assert_return(m, -EINVAL);
|
||||
assert_return(m->sealed, -EINVAL);
|
||||
assert_return(m->n_containers > 0, -EINVAL);
|
||||
@ -1330,27 +1330,27 @@ int sd_rtnl_message_exit_container(sd_rtnl_message *m) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t rtnl_message_get_serial(sd_rtnl_message *m) {
|
||||
uint32_t rtnl_message_get_serial(sd_netlink_message *m) {
|
||||
assert(m);
|
||||
assert(m->hdr);
|
||||
|
||||
return m->hdr->nlmsg_seq;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_is_error(sd_rtnl_message *m) {
|
||||
int sd_netlink_message_is_error(sd_netlink_message *m) {
|
||||
assert_return(m, 0);
|
||||
assert_return(m->hdr, 0);
|
||||
|
||||
return m->hdr->nlmsg_type == NLMSG_ERROR;
|
||||
}
|
||||
|
||||
int sd_rtnl_message_get_errno(sd_rtnl_message *m) {
|
||||
int sd_netlink_message_get_errno(sd_netlink_message *m) {
|
||||
struct nlmsgerr *err;
|
||||
|
||||
assert_return(m, -EINVAL);
|
||||
assert_return(m->hdr, -EINVAL);
|
||||
|
||||
if (!sd_rtnl_message_is_error(m))
|
||||
if (!sd_netlink_message_is_error(m))
|
||||
return 0;
|
||||
|
||||
err = NLMSG_DATA(m->hdr);
|
||||
@ -1358,7 +1358,7 @@ int sd_rtnl_message_get_errno(sd_rtnl_message *m) {
|
||||
return err->error;
|
||||
}
|
||||
|
||||
int rtnl_message_parse(sd_rtnl_message *m,
|
||||
int rtnl_message_parse(sd_netlink_message *m,
|
||||
size_t **rta_offset_tb,
|
||||
unsigned short *rta_tb_size,
|
||||
int max,
|
||||
@ -1394,7 +1394,7 @@ int rtnl_message_parse(sd_rtnl_message *m,
|
||||
}
|
||||
|
||||
/* returns the number of bytes sent, or a negative error code */
|
||||
int socket_write_message(sd_rtnl *nl, sd_rtnl_message *m) {
|
||||
int socket_write_message(sd_netlink *nl, sd_netlink_message *m) {
|
||||
union {
|
||||
struct sockaddr sa;
|
||||
struct sockaddr_nl nl;
|
||||
@ -1480,8 +1480,8 @@ static int socket_recv_message(int fd, struct iovec *iov, uint32_t *_group, bool
|
||||
* If nothing useful was received 0 is returned.
|
||||
* On failure, a negative error code is returned.
|
||||
*/
|
||||
int socket_read_message(sd_rtnl *rtnl) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *first = NULL;
|
||||
int socket_read_message(sd_netlink *rtnl) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *first = NULL;
|
||||
struct iovec iov = {};
|
||||
uint32_t group = 0;
|
||||
bool multi_part = false, done = false;
|
||||
@ -1534,7 +1534,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
}
|
||||
|
||||
for (new_msg = rtnl->rbuffer; NLMSG_OK(new_msg, len) && !done; new_msg = NLMSG_NEXT(new_msg, len)) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
const NLType *nl_type;
|
||||
|
||||
if (!group && new_msg->nlmsg_pid != rtnl->sockaddr.nl.nl_pid)
|
||||
@ -1558,7 +1558,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
r = type_system_get_type(NULL, &nl_type, new_msg->nlmsg_type);
|
||||
if (r < 0) {
|
||||
if (r == -EOPNOTSUPP)
|
||||
log_debug("sd-rtnl: ignored message with unknown type: %i",
|
||||
log_debug("sd-netlink: ignored message with unknown type: %i",
|
||||
new_msg->nlmsg_type);
|
||||
|
||||
continue;
|
||||
@ -1566,7 +1566,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
|
||||
/* check that the size matches the message type */
|
||||
if (new_msg->nlmsg_len < NLMSG_LENGTH(nl_type->size)) {
|
||||
log_debug("sd-rtnl: message larger than expected, dropping");
|
||||
log_debug("sd-netlink: message larger than expected, dropping");
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -1581,7 +1581,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
return -ENOMEM;
|
||||
|
||||
/* seal and parse the top-level message */
|
||||
r = sd_rtnl_message_rewind(m);
|
||||
r = sd_netlink_message_rewind(m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -1593,7 +1593,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
}
|
||||
|
||||
if (len)
|
||||
log_debug("sd-rtnl: discarding %zu bytes of incoming message", len);
|
||||
log_debug("sd-netlink: discarding %zu bytes of incoming message", len);
|
||||
|
||||
if (!first)
|
||||
return 0;
|
||||
@ -1610,7 +1610,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
if (multi_part && (i < rtnl->rqueue_partial_size)) {
|
||||
/* remove the message form the partial read queue */
|
||||
memmove(rtnl->rqueue_partial + i,rtnl->rqueue_partial + i + 1,
|
||||
sizeof(sd_rtnl_message*) * (rtnl->rqueue_partial_size - i - 1));
|
||||
sizeof(sd_netlink_message*) * (rtnl->rqueue_partial_size - i - 1));
|
||||
rtnl->rqueue_partial_size --;
|
||||
}
|
||||
|
||||
@ -1633,7 +1633,7 @@ int socket_read_message(sd_rtnl *rtnl) {
|
||||
}
|
||||
}
|
||||
|
||||
int sd_rtnl_message_rewind(sd_rtnl_message *m) {
|
||||
int sd_netlink_message_rewind(sd_netlink_message *m) {
|
||||
const NLType *type;
|
||||
unsigned i;
|
||||
int r;
|
||||
@ -1685,14 +1685,14 @@ int sd_rtnl_message_rewind(sd_rtnl_message *m) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
void rtnl_message_seal(sd_rtnl_message *m) {
|
||||
void rtnl_message_seal(sd_netlink_message *m) {
|
||||
assert(m);
|
||||
assert(!m->sealed);
|
||||
|
||||
m->sealed = true;
|
||||
}
|
||||
|
||||
sd_rtnl_message *sd_rtnl_message_next(sd_rtnl_message *m) {
|
||||
sd_netlink_message *sd_netlink_message_next(sd_netlink_message *m) {
|
||||
assert_return(m, NULL);
|
||||
|
||||
return m->next;
|
@ -36,7 +36,7 @@
|
||||
#include "macro.h"
|
||||
#include "util.h"
|
||||
|
||||
#include "rtnl-types.h"
|
||||
#include "netlink-types.h"
|
||||
#include "missing.h"
|
||||
|
||||
static const NLTypeSystem rtnl_link_type_system;
|
@ -20,13 +20,13 @@
|
||||
***/
|
||||
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
|
||||
#include "rtnl-util.h"
|
||||
#include "rtnl-internal.h"
|
||||
#include "netlink-util.h"
|
||||
#include "netlink-internal.h"
|
||||
|
||||
int rtnl_set_link_name(sd_rtnl **rtnl, int ifindex, const char *name) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL;
|
||||
int rtnl_set_link_name(sd_netlink **rtnl, int ifindex, const char *name) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *message = NULL;
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
@ -34,7 +34,7 @@ int rtnl_set_link_name(sd_rtnl **rtnl, int ifindex, const char *name) {
|
||||
assert(name);
|
||||
|
||||
if (!*rtnl) {
|
||||
r = sd_rtnl_open(rtnl);
|
||||
r = sd_netlink_open(rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
@ -43,20 +43,20 @@ int rtnl_set_link_name(sd_rtnl **rtnl, int ifindex, const char *name) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_append_string(message, IFLA_IFNAME, name);
|
||||
r = sd_netlink_message_append_string(message, IFLA_IFNAME, name);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(*rtnl, message, 0, NULL);
|
||||
r = sd_netlink_call(*rtnl, message, 0, NULL);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int rtnl_set_link_properties(sd_rtnl **rtnl, int ifindex, const char *alias,
|
||||
int rtnl_set_link_properties(sd_netlink **rtnl, int ifindex, const char *alias,
|
||||
const struct ether_addr *mac, unsigned mtu) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *message = NULL;
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
@ -66,7 +66,7 @@ int rtnl_set_link_properties(sd_rtnl **rtnl, int ifindex, const char *alias,
|
||||
return 0;
|
||||
|
||||
if (!*rtnl) {
|
||||
r = sd_rtnl_open(rtnl);
|
||||
r = sd_netlink_open(rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
@ -76,31 +76,31 @@ int rtnl_set_link_properties(sd_rtnl **rtnl, int ifindex, const char *alias,
|
||||
return r;
|
||||
|
||||
if (alias) {
|
||||
r = sd_rtnl_message_append_string(message, IFLA_IFALIAS, alias);
|
||||
r = sd_netlink_message_append_string(message, IFLA_IFALIAS, alias);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
|
||||
if (mac) {
|
||||
r = sd_rtnl_message_append_ether_addr(message, IFLA_ADDRESS, mac);
|
||||
r = sd_netlink_message_append_ether_addr(message, IFLA_ADDRESS, mac);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
|
||||
if (mtu > 0) {
|
||||
r = sd_rtnl_message_append_u32(message, IFLA_MTU, mtu);
|
||||
r = sd_netlink_message_append_u32(message, IFLA_MTU, mtu);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
|
||||
r = sd_rtnl_call(*rtnl, message, 0, NULL);
|
||||
r = sd_netlink_call(*rtnl, message, 0, NULL);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **ret) {
|
||||
int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_netlink_message **ret) {
|
||||
struct nlmsgerr *err;
|
||||
int r;
|
||||
|
@ -23,25 +23,25 @@
|
||||
|
||||
|
||||
#include "util.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
|
||||
int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **ret);
|
||||
uint32_t rtnl_message_get_serial(sd_rtnl_message *m);
|
||||
void rtnl_message_seal(sd_rtnl_message *m);
|
||||
int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_netlink_message **ret);
|
||||
uint32_t rtnl_message_get_serial(sd_netlink_message *m);
|
||||
void rtnl_message_seal(sd_netlink_message *m);
|
||||
|
||||
bool rtnl_message_type_is_link(uint16_t type);
|
||||
bool rtnl_message_type_is_addr(uint16_t type);
|
||||
bool rtnl_message_type_is_route(uint16_t type);
|
||||
bool rtnl_message_type_is_neigh(uint16_t type);
|
||||
|
||||
int rtnl_set_link_name(sd_rtnl **rtnl, int ifindex, const char *name);
|
||||
int rtnl_set_link_properties(sd_rtnl **rtnl, int ifindex, const char *alias, const struct ether_addr *mac, unsigned mtu);
|
||||
int rtnl_set_link_name(sd_netlink **rtnl, int ifindex, const char *name);
|
||||
int rtnl_set_link_properties(sd_netlink **rtnl, int ifindex, const char *alias, const struct ether_addr *mac, unsigned mtu);
|
||||
|
||||
int rtnl_log_parse_error(int r);
|
||||
int rtnl_log_create_error(int r);
|
||||
|
||||
DEFINE_TRIVIAL_CLEANUP_FUNC(sd_rtnl*, sd_rtnl_unref);
|
||||
DEFINE_TRIVIAL_CLEANUP_FUNC(sd_rtnl_message*, sd_rtnl_message_unref);
|
||||
DEFINE_TRIVIAL_CLEANUP_FUNC(sd_netlink*, sd_netlink_unref);
|
||||
DEFINE_TRIVIAL_CLEANUP_FUNC(sd_netlink_message*, sd_netlink_message_unref);
|
||||
|
||||
#define _cleanup_rtnl_unref_ _cleanup_(sd_rtnl_unrefp)
|
||||
#define _cleanup_rtnl_message_unref_ _cleanup_(sd_rtnl_message_unrefp)
|
||||
#define _cleanup_netlink_unref_ _cleanup_(sd_netlink_unrefp)
|
||||
#define _cleanup_netlink_message_unref_ _cleanup_(sd_netlink_message_unrefp)
|
@ -27,16 +27,16 @@
|
||||
#include "util.h"
|
||||
#include "hashmap.h"
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "rtnl-internal.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "netlink-internal.h"
|
||||
#include "netlink-util.h"
|
||||
|
||||
static int sd_rtnl_new(sd_rtnl **ret) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
static int sd_netlink_new(sd_netlink **ret) {
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
|
||||
assert_return(ret, -EINVAL);
|
||||
|
||||
rtnl = new0(sd_rtnl, 1);
|
||||
rtnl = new0(sd_netlink, 1);
|
||||
if (!rtnl)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -72,14 +72,14 @@ static int sd_rtnl_new(sd_rtnl **ret) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_new_from_netlink(sd_rtnl **ret, int fd) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
int sd_netlink_new_from_netlink(sd_netlink **ret, int fd) {
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
socklen_t addrlen;
|
||||
int r;
|
||||
|
||||
assert_return(ret, -EINVAL);
|
||||
|
||||
r = sd_rtnl_new(&rtnl);
|
||||
r = sd_netlink_new(&rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -97,7 +97,7 @@ int sd_rtnl_new_from_netlink(sd_rtnl **ret, int fd) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool rtnl_pid_changed(sd_rtnl *rtnl) {
|
||||
static bool rtnl_pid_changed(sd_netlink *rtnl) {
|
||||
assert(rtnl);
|
||||
|
||||
/* We don't support people creating an rtnl connection and
|
||||
@ -106,15 +106,15 @@ static bool rtnl_pid_changed(sd_rtnl *rtnl) {
|
||||
return rtnl->original_pid != getpid();
|
||||
}
|
||||
|
||||
int sd_rtnl_open_fd(sd_rtnl **ret, int fd) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
int sd_netlink_open_fd(sd_netlink **ret, int fd) {
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
socklen_t addrlen;
|
||||
int r, one = 1;
|
||||
|
||||
assert_return(ret, -EINVAL);
|
||||
assert_return(fd >= 0, -EINVAL);
|
||||
|
||||
r = sd_rtnl_new(&rtnl);
|
||||
r = sd_netlink_new(&rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -141,7 +141,7 @@ int sd_rtnl_open_fd(sd_rtnl **ret, int fd) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_open(sd_rtnl **ret) {
|
||||
int sd_netlink_open(sd_netlink **ret) {
|
||||
_cleanup_close_ int fd = -1;
|
||||
int r;
|
||||
|
||||
@ -149,7 +149,7 @@ int sd_rtnl_open(sd_rtnl **ret) {
|
||||
if (fd < 0)
|
||||
return -errno;
|
||||
|
||||
r = sd_rtnl_open_fd(ret, fd);
|
||||
r = sd_netlink_open_fd(ret, fd);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -158,7 +158,7 @@ int sd_rtnl_open(sd_rtnl **ret) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int rtnl_join_broadcast_group(sd_rtnl *rtnl, unsigned group) {
|
||||
static int rtnl_join_broadcast_group(sd_netlink *rtnl, unsigned group) {
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
@ -172,11 +172,11 @@ static int rtnl_join_broadcast_group(sd_rtnl *rtnl, unsigned group) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_inc_rcvbuf(const sd_rtnl *const rtnl, const int size) {
|
||||
int sd_netlink_inc_rcvbuf(const sd_netlink *const rtnl, const int size) {
|
||||
return fd_inc_rcvbuf(rtnl->fd, size);
|
||||
}
|
||||
|
||||
sd_rtnl *sd_rtnl_ref(sd_rtnl *rtnl) {
|
||||
sd_netlink *sd_netlink_ref(sd_netlink *rtnl) {
|
||||
assert_return(rtnl, NULL);
|
||||
assert_return(!rtnl_pid_changed(rtnl), NULL);
|
||||
|
||||
@ -186,7 +186,7 @@ sd_rtnl *sd_rtnl_ref(sd_rtnl *rtnl) {
|
||||
return rtnl;
|
||||
}
|
||||
|
||||
sd_rtnl *sd_rtnl_unref(sd_rtnl *rtnl) {
|
||||
sd_netlink *sd_netlink_unref(sd_netlink *rtnl) {
|
||||
if (!rtnl)
|
||||
return NULL;
|
||||
|
||||
@ -197,15 +197,15 @@ sd_rtnl *sd_rtnl_unref(sd_rtnl *rtnl) {
|
||||
unsigned i;
|
||||
|
||||
for (i = 0; i < rtnl->rqueue_size; i++)
|
||||
sd_rtnl_message_unref(rtnl->rqueue[i]);
|
||||
sd_netlink_message_unref(rtnl->rqueue[i]);
|
||||
free(rtnl->rqueue);
|
||||
|
||||
for (i = 0; i < rtnl->rqueue_partial_size; i++)
|
||||
sd_rtnl_message_unref(rtnl->rqueue_partial[i]);
|
||||
sd_netlink_message_unref(rtnl->rqueue_partial[i]);
|
||||
free(rtnl->rqueue_partial);
|
||||
|
||||
for (i = 0; i < rtnl->wqueue_size; i++)
|
||||
sd_rtnl_message_unref(rtnl->wqueue[i]);
|
||||
sd_netlink_message_unref(rtnl->wqueue[i]);
|
||||
free(rtnl->wqueue);
|
||||
|
||||
free(rtnl->rbuffer);
|
||||
@ -230,7 +230,7 @@ sd_rtnl *sd_rtnl_unref(sd_rtnl *rtnl) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void rtnl_seal_message(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
static void rtnl_seal_message(sd_netlink *rtnl, sd_netlink_message *m) {
|
||||
assert(rtnl);
|
||||
assert(!rtnl_pid_changed(rtnl));
|
||||
assert(m);
|
||||
@ -245,8 +245,8 @@ static void rtnl_seal_message(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
return;
|
||||
}
|
||||
|
||||
int sd_rtnl_send(sd_rtnl *nl,
|
||||
sd_rtnl_message *message,
|
||||
int sd_netlink_send(sd_netlink *nl,
|
||||
sd_netlink_message *message,
|
||||
uint32_t *serial) {
|
||||
int r;
|
||||
|
||||
@ -265,7 +265,7 @@ int sd_rtnl_send(sd_rtnl *nl,
|
||||
else if (r == 0) {
|
||||
/* nothing was sent, so let's put it on
|
||||
* the queue */
|
||||
nl->wqueue[0] = sd_rtnl_message_ref(message);
|
||||
nl->wqueue[0] = sd_netlink_message_ref(message);
|
||||
nl->wqueue_size = 1;
|
||||
}
|
||||
} else {
|
||||
@ -278,7 +278,7 @@ int sd_rtnl_send(sd_rtnl *nl,
|
||||
if (!GREEDY_REALLOC(nl->wqueue, nl->wqueue_allocated, nl->wqueue_size + 1))
|
||||
return -ENOMEM;
|
||||
|
||||
nl->wqueue[nl->wqueue_size ++] = sd_rtnl_message_ref(message);
|
||||
nl->wqueue[nl->wqueue_size ++] = sd_netlink_message_ref(message);
|
||||
}
|
||||
|
||||
if (serial)
|
||||
@ -287,7 +287,7 @@ int sd_rtnl_send(sd_rtnl *nl,
|
||||
return 1;
|
||||
}
|
||||
|
||||
int rtnl_rqueue_make_room(sd_rtnl *rtnl) {
|
||||
int rtnl_rqueue_make_room(sd_netlink *rtnl) {
|
||||
assert(rtnl);
|
||||
|
||||
if (rtnl->rqueue_size >= RTNL_RQUEUE_MAX) {
|
||||
@ -301,7 +301,7 @@ int rtnl_rqueue_make_room(sd_rtnl *rtnl) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int rtnl_rqueue_partial_make_room(sd_rtnl *rtnl) {
|
||||
int rtnl_rqueue_partial_make_room(sd_netlink *rtnl) {
|
||||
assert(rtnl);
|
||||
|
||||
if (rtnl->rqueue_partial_size >= RTNL_RQUEUE_MAX) {
|
||||
@ -316,7 +316,7 @@ int rtnl_rqueue_partial_make_room(sd_rtnl *rtnl) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dispatch_rqueue(sd_rtnl *rtnl, sd_rtnl_message **message) {
|
||||
static int dispatch_rqueue(sd_netlink *rtnl, sd_netlink_message **message) {
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
@ -332,12 +332,12 @@ static int dispatch_rqueue(sd_rtnl *rtnl, sd_rtnl_message **message) {
|
||||
/* Dispatch a queued message */
|
||||
*message = rtnl->rqueue[0];
|
||||
rtnl->rqueue_size --;
|
||||
memmove(rtnl->rqueue, rtnl->rqueue + 1, sizeof(sd_rtnl_message*) * rtnl->rqueue_size);
|
||||
memmove(rtnl->rqueue, rtnl->rqueue + 1, sizeof(sd_netlink_message*) * rtnl->rqueue_size);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int dispatch_wqueue(sd_rtnl *rtnl) {
|
||||
static int dispatch_wqueue(sd_netlink *rtnl) {
|
||||
int r, ret = 0;
|
||||
|
||||
assert(rtnl);
|
||||
@ -351,9 +351,9 @@ static int dispatch_wqueue(sd_rtnl *rtnl) {
|
||||
return ret;
|
||||
else {
|
||||
/* see equivalent in sd-bus.c */
|
||||
sd_rtnl_message_unref(rtnl->wqueue[0]);
|
||||
sd_netlink_message_unref(rtnl->wqueue[0]);
|
||||
rtnl->wqueue_size --;
|
||||
memmove(rtnl->wqueue, rtnl->wqueue + 1, sizeof(sd_rtnl_message*) * rtnl->wqueue_size);
|
||||
memmove(rtnl->wqueue, rtnl->wqueue + 1, sizeof(sd_netlink_message*) * rtnl->wqueue_size);
|
||||
|
||||
ret = 1;
|
||||
}
|
||||
@ -362,8 +362,8 @@ static int dispatch_wqueue(sd_rtnl *rtnl) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int process_timeout(sd_rtnl *rtnl) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
static int process_timeout(sd_netlink *rtnl) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
struct reply_callback *c;
|
||||
usec_t n;
|
||||
int r;
|
||||
@ -387,14 +387,14 @@ static int process_timeout(sd_rtnl *rtnl) {
|
||||
|
||||
r = c->callback(rtnl, m, c->userdata);
|
||||
if (r < 0)
|
||||
log_debug_errno(r, "sd-rtnl: timedout callback failed: %m");
|
||||
log_debug_errno(r, "sd-netlink: timedout callback failed: %m");
|
||||
|
||||
free(c);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int process_reply(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
static int process_reply(sd_netlink *rtnl, sd_netlink_message *m) {
|
||||
_cleanup_free_ struct reply_callback *c = NULL;
|
||||
uint64_t serial;
|
||||
uint16_t type;
|
||||
@ -411,7 +411,7 @@ static int process_reply(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
if (c->timeout != 0)
|
||||
prioq_remove(rtnl->reply_callbacks_prioq, c, &c->prioq_idx);
|
||||
|
||||
r = sd_rtnl_message_get_type(m, &type);
|
||||
r = sd_netlink_message_get_type(m, &type);
|
||||
if (r < 0)
|
||||
return 0;
|
||||
|
||||
@ -420,12 +420,12 @@ static int process_reply(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
|
||||
r = c->callback(rtnl, m, c->userdata);
|
||||
if (r < 0)
|
||||
log_debug_errno(r, "sd-rtnl: callback failed: %m");
|
||||
log_debug_errno(r, "sd-netlink: callback failed: %m");
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int process_match(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
static int process_match(sd_netlink *rtnl, sd_netlink_message *m) {
|
||||
struct match_callback *c;
|
||||
uint16_t type;
|
||||
int r;
|
||||
@ -433,7 +433,7 @@ static int process_match(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
assert(rtnl);
|
||||
assert(m);
|
||||
|
||||
r = sd_rtnl_message_get_type(m, &type);
|
||||
r = sd_netlink_message_get_type(m, &type);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -442,7 +442,7 @@ static int process_match(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
r = c->callback(rtnl, m, c->userdata);
|
||||
if (r != 0) {
|
||||
if (r < 0)
|
||||
log_debug_errno(r, "sd-rtnl: match callback failed: %m");
|
||||
log_debug_errno(r, "sd-netlink: match callback failed: %m");
|
||||
|
||||
break;
|
||||
}
|
||||
@ -452,8 +452,8 @@ static int process_match(sd_rtnl *rtnl, sd_rtnl_message *m) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int process_running(sd_rtnl *rtnl, sd_rtnl_message **ret) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
static int process_running(sd_netlink *rtnl, sd_netlink_message **ret) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
@ -472,7 +472,7 @@ static int process_running(sd_rtnl *rtnl, sd_rtnl_message **ret) {
|
||||
if (!m)
|
||||
goto null_message;
|
||||
|
||||
if (sd_rtnl_message_is_broadcast(m)) {
|
||||
if (sd_netlink_message_is_broadcast(m)) {
|
||||
r = process_match(rtnl, m);
|
||||
if (r != 0)
|
||||
goto null_message;
|
||||
@ -498,7 +498,7 @@ null_message:
|
||||
return r;
|
||||
}
|
||||
|
||||
int sd_rtnl_process(sd_rtnl *rtnl, sd_rtnl_message **ret) {
|
||||
int sd_netlink_process(sd_netlink *rtnl, sd_netlink_message **ret) {
|
||||
RTNL_DONT_DESTROY(rtnl);
|
||||
int r;
|
||||
|
||||
@ -523,7 +523,7 @@ static usec_t calc_elapse(uint64_t usec) {
|
||||
return now(CLOCK_MONOTONIC) + usec;
|
||||
}
|
||||
|
||||
static int rtnl_poll(sd_rtnl *rtnl, bool need_more, uint64_t timeout_usec) {
|
||||
static int rtnl_poll(sd_netlink *rtnl, bool need_more, uint64_t timeout_usec) {
|
||||
struct pollfd p[1] = {};
|
||||
struct timespec ts;
|
||||
usec_t m = USEC_INFINITY;
|
||||
@ -531,7 +531,7 @@ static int rtnl_poll(sd_rtnl *rtnl, bool need_more, uint64_t timeout_usec) {
|
||||
|
||||
assert(rtnl);
|
||||
|
||||
e = sd_rtnl_get_events(rtnl);
|
||||
e = sd_netlink_get_events(rtnl);
|
||||
if (e < 0)
|
||||
return e;
|
||||
|
||||
@ -544,7 +544,7 @@ static int rtnl_poll(sd_rtnl *rtnl, bool need_more, uint64_t timeout_usec) {
|
||||
/* Caller wants to process if there is something to
|
||||
* process, but doesn't care otherwise */
|
||||
|
||||
r = sd_rtnl_get_timeout(rtnl, &until);
|
||||
r = sd_netlink_get_timeout(rtnl, &until);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (r > 0) {
|
||||
@ -567,7 +567,7 @@ static int rtnl_poll(sd_rtnl *rtnl, bool need_more, uint64_t timeout_usec) {
|
||||
return r > 0 ? 1 : 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_wait(sd_rtnl *nl, uint64_t timeout_usec) {
|
||||
int sd_netlink_wait(sd_netlink *nl, uint64_t timeout_usec) {
|
||||
assert_return(nl, -EINVAL);
|
||||
assert_return(!rtnl_pid_changed(nl), -ECHILD);
|
||||
|
||||
@ -595,9 +595,9 @@ static int timeout_compare(const void *a, const void *b) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_call_async(sd_rtnl *nl,
|
||||
sd_rtnl_message *m,
|
||||
sd_rtnl_message_handler_t callback,
|
||||
int sd_netlink_call_async(sd_netlink *nl,
|
||||
sd_netlink_message *m,
|
||||
sd_netlink_message_handler_t callback,
|
||||
void *userdata,
|
||||
uint64_t usec,
|
||||
uint32_t *serial) {
|
||||
@ -628,7 +628,7 @@ int sd_rtnl_call_async(sd_rtnl *nl,
|
||||
c->userdata = userdata;
|
||||
c->timeout = calc_elapse(usec);
|
||||
|
||||
k = sd_rtnl_send(nl, m, &s);
|
||||
k = sd_netlink_send(nl, m, &s);
|
||||
if (k < 0) {
|
||||
free(c);
|
||||
return k;
|
||||
@ -646,7 +646,7 @@ int sd_rtnl_call_async(sd_rtnl *nl,
|
||||
r = prioq_put(nl->reply_callbacks_prioq, c, &c->prioq_idx);
|
||||
if (r > 0) {
|
||||
c->timeout = 0;
|
||||
sd_rtnl_call_async_cancel(nl, c->serial);
|
||||
sd_netlink_call_async_cancel(nl, c->serial);
|
||||
return r;
|
||||
}
|
||||
}
|
||||
@ -657,7 +657,7 @@ int sd_rtnl_call_async(sd_rtnl *nl,
|
||||
return k;
|
||||
}
|
||||
|
||||
int sd_rtnl_call_async_cancel(sd_rtnl *nl, uint32_t serial) {
|
||||
int sd_netlink_call_async_cancel(sd_netlink *nl, uint32_t serial) {
|
||||
struct reply_callback *c;
|
||||
uint64_t s = serial;
|
||||
|
||||
@ -676,10 +676,10 @@ int sd_rtnl_call_async_cancel(sd_rtnl *nl, uint32_t serial) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
int sd_rtnl_call(sd_rtnl *rtnl,
|
||||
sd_rtnl_message *message,
|
||||
int sd_netlink_call(sd_netlink *rtnl,
|
||||
sd_netlink_message *message,
|
||||
uint64_t usec,
|
||||
sd_rtnl_message **ret) {
|
||||
sd_netlink_message **ret) {
|
||||
usec_t timeout;
|
||||
uint32_t serial;
|
||||
int r;
|
||||
@ -688,7 +688,7 @@ int sd_rtnl_call(sd_rtnl *rtnl,
|
||||
assert_return(!rtnl_pid_changed(rtnl), -ECHILD);
|
||||
assert_return(message, -EINVAL);
|
||||
|
||||
r = sd_rtnl_send(rtnl, message, &serial);
|
||||
r = sd_netlink_send(rtnl, message, &serial);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -704,21 +704,21 @@ int sd_rtnl_call(sd_rtnl *rtnl,
|
||||
received_serial = rtnl_message_get_serial(rtnl->rqueue[i]);
|
||||
|
||||
if (received_serial == serial) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *incoming = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *incoming = NULL;
|
||||
uint16_t type;
|
||||
|
||||
incoming = rtnl->rqueue[i];
|
||||
|
||||
/* found a match, remove from rqueue and return it */
|
||||
memmove(rtnl->rqueue + i,rtnl->rqueue + i + 1,
|
||||
sizeof(sd_rtnl_message*) * (rtnl->rqueue_size - i - 1));
|
||||
sizeof(sd_netlink_message*) * (rtnl->rqueue_size - i - 1));
|
||||
rtnl->rqueue_size--;
|
||||
|
||||
r = sd_rtnl_message_get_errno(incoming);
|
||||
r = sd_netlink_message_get_errno(incoming);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_get_type(incoming, &type);
|
||||
r = sd_netlink_message_get_type(incoming, &type);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -766,7 +766,7 @@ int sd_rtnl_call(sd_rtnl *rtnl,
|
||||
}
|
||||
}
|
||||
|
||||
int sd_rtnl_flush(sd_rtnl *rtnl) {
|
||||
int sd_netlink_flush(sd_netlink *rtnl) {
|
||||
int r;
|
||||
|
||||
assert_return(rtnl, -EINVAL);
|
||||
@ -789,7 +789,7 @@ int sd_rtnl_flush(sd_rtnl *rtnl) {
|
||||
}
|
||||
}
|
||||
|
||||
int sd_rtnl_get_events(sd_rtnl *rtnl) {
|
||||
int sd_netlink_get_events(sd_netlink *rtnl) {
|
||||
int flags = 0;
|
||||
|
||||
assert_return(rtnl, -EINVAL);
|
||||
@ -803,7 +803,7 @@ int sd_rtnl_get_events(sd_rtnl *rtnl) {
|
||||
return flags;
|
||||
}
|
||||
|
||||
int sd_rtnl_get_timeout(sd_rtnl *rtnl, uint64_t *timeout_usec) {
|
||||
int sd_netlink_get_timeout(sd_netlink *rtnl, uint64_t *timeout_usec) {
|
||||
struct reply_callback *c;
|
||||
|
||||
assert_return(rtnl, -EINVAL);
|
||||
@ -827,12 +827,12 @@ int sd_rtnl_get_timeout(sd_rtnl *rtnl, uint64_t *timeout_usec) {
|
||||
}
|
||||
|
||||
static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
|
||||
sd_rtnl *rtnl = userdata;
|
||||
sd_netlink *rtnl = userdata;
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
|
||||
r = sd_rtnl_process(rtnl, NULL);
|
||||
r = sd_netlink_process(rtnl, NULL);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -840,12 +840,12 @@ static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userd
|
||||
}
|
||||
|
||||
static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
|
||||
sd_rtnl *rtnl = userdata;
|
||||
sd_netlink *rtnl = userdata;
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
|
||||
r = sd_rtnl_process(rtnl, NULL);
|
||||
r = sd_netlink_process(rtnl, NULL);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -853,14 +853,14 @@ static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
|
||||
}
|
||||
|
||||
static int prepare_callback(sd_event_source *s, void *userdata) {
|
||||
sd_rtnl *rtnl = userdata;
|
||||
sd_netlink *rtnl = userdata;
|
||||
int r, e;
|
||||
usec_t until;
|
||||
|
||||
assert(s);
|
||||
assert(rtnl);
|
||||
|
||||
e = sd_rtnl_get_events(rtnl);
|
||||
e = sd_netlink_get_events(rtnl);
|
||||
if (e < 0)
|
||||
return e;
|
||||
|
||||
@ -868,7 +868,7 @@ static int prepare_callback(sd_event_source *s, void *userdata) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_get_timeout(rtnl, &until);
|
||||
r = sd_netlink_get_timeout(rtnl, &until);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (r > 0) {
|
||||
@ -887,16 +887,16 @@ static int prepare_callback(sd_event_source *s, void *userdata) {
|
||||
}
|
||||
|
||||
static int exit_callback(sd_event_source *event, void *userdata) {
|
||||
sd_rtnl *rtnl = userdata;
|
||||
sd_netlink *rtnl = userdata;
|
||||
|
||||
assert(event);
|
||||
|
||||
sd_rtnl_flush(rtnl);
|
||||
sd_netlink_flush(rtnl);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int sd_rtnl_attach_event(sd_rtnl *rtnl, sd_event *event, int priority) {
|
||||
int sd_netlink_attach_event(sd_netlink *rtnl, sd_event *event, int priority) {
|
||||
int r;
|
||||
|
||||
assert_return(rtnl, -EINVAL);
|
||||
@ -952,11 +952,11 @@ int sd_rtnl_attach_event(sd_rtnl *rtnl, sd_event *event, int priority) {
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
sd_rtnl_detach_event(rtnl);
|
||||
sd_netlink_detach_event(rtnl);
|
||||
return r;
|
||||
}
|
||||
|
||||
int sd_rtnl_detach_event(sd_rtnl *rtnl) {
|
||||
int sd_netlink_detach_event(sd_netlink *rtnl) {
|
||||
assert_return(rtnl, -EINVAL);
|
||||
assert_return(rtnl->event, -ENXIO);
|
||||
|
||||
@ -975,9 +975,9 @@ int sd_rtnl_detach_event(sd_rtnl *rtnl) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_add_match(sd_rtnl *rtnl,
|
||||
int sd_netlink_add_match(sd_netlink *rtnl,
|
||||
uint16_t type,
|
||||
sd_rtnl_message_handler_t callback,
|
||||
sd_netlink_message_handler_t callback,
|
||||
void *userdata) {
|
||||
_cleanup_free_ struct match_callback *c = NULL;
|
||||
int r;
|
||||
@ -1027,9 +1027,9 @@ int sd_rtnl_add_match(sd_rtnl *rtnl,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sd_rtnl_remove_match(sd_rtnl *rtnl,
|
||||
int sd_netlink_remove_match(sd_netlink *rtnl,
|
||||
uint16_t type,
|
||||
sd_rtnl_message_handler_t callback,
|
||||
sd_netlink_message_handler_t callback,
|
||||
void *userdata) {
|
||||
struct match_callback *c;
|
||||
|
443
src/libsystemd/sd-netlink/test-netlink.c
Normal file
443
src/libsystemd/sd-netlink/test-netlink.c
Normal file
@ -0,0 +1,443 @@
|
||||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
||||
|
||||
/***
|
||||
This file is part of systemd.
|
||||
|
||||
Copyright 2013 Tom Gundersen <teg@jklm.no>
|
||||
|
||||
systemd 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.
|
||||
|
||||
systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
|
||||
***/
|
||||
|
||||
#include <netinet/ether.h>
|
||||
#include <net/if.h>
|
||||
|
||||
#include "util.h"
|
||||
#include "macro.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "socket-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "event-util.h"
|
||||
#include "missing.h"
|
||||
|
||||
static void test_message_link_bridge(sd_netlink *rtnl) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *message = NULL;
|
||||
uint32_t cost;
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_NEWLINK, 1) >= 0);
|
||||
assert_se(sd_rtnl_message_link_set_family(message, PF_BRIDGE) >= 0);
|
||||
assert_se(sd_netlink_message_open_container(message, IFLA_PROTINFO) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(message, IFLA_BRPORT_COST, 10) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(message) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_rewind(message) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_enter_container(message, IFLA_PROTINFO) >= 0);
|
||||
assert_se(sd_netlink_message_read_u32(message, IFLA_BRPORT_COST, &cost) >= 0);
|
||||
assert_se(cost == 10);
|
||||
assert_se(sd_netlink_message_exit_container(message) >= 0);
|
||||
}
|
||||
|
||||
static void test_link_configure(sd_netlink *rtnl, int ifindex) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *message = NULL;
|
||||
const char *mac = "98:fe:94:3f:c6:18", *name = "test";
|
||||
char buffer[ETHER_ADDR_TO_STRING_MAX];
|
||||
unsigned int mtu = 1450, mtu_out;
|
||||
const char *name_out;
|
||||
struct ether_addr mac_out;
|
||||
|
||||
/* we'd really like to test NEWLINK, but let's not mess with the running kernel */
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, ifindex) >= 0);
|
||||
assert_se(sd_netlink_message_append_string(message, IFLA_IFNAME, name) >= 0);
|
||||
assert_se(sd_netlink_message_append_ether_addr(message, IFLA_ADDRESS, ether_aton(mac)) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(message, IFLA_MTU, mtu) >= 0);
|
||||
|
||||
assert_se(sd_netlink_call(rtnl, message, 0, NULL) == 1);
|
||||
assert_se(sd_netlink_message_rewind(message) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_string(message, IFLA_IFNAME, &name_out) >= 0);
|
||||
assert_se(streq(name, name_out));
|
||||
|
||||
assert_se(sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &mac_out) >= 0);
|
||||
assert_se(streq(mac, ether_addr_to_string(&mac_out, buffer)));
|
||||
|
||||
assert_se(sd_netlink_message_read_u32(message, IFLA_MTU, &mtu_out) >= 0);
|
||||
assert_se(mtu == mtu_out);
|
||||
}
|
||||
|
||||
static void test_link_get(sd_netlink *rtnl, int ifindex) {
|
||||
sd_netlink_message *m;
|
||||
sd_netlink_message *r;
|
||||
unsigned int mtu = 1500;
|
||||
const char *str_data;
|
||||
uint8_t u8_data;
|
||||
uint32_t u32_data;
|
||||
struct ether_addr eth_data;
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
/* u8 test cases */
|
||||
assert_se(sd_netlink_message_append_u8(m, IFLA_CARRIER, 0) >= 0);
|
||||
assert_se(sd_netlink_message_append_u8(m, IFLA_OPERSTATE, 0) >= 0);
|
||||
assert_se(sd_netlink_message_append_u8(m, IFLA_LINKMODE, 0) >= 0);
|
||||
|
||||
/* u32 test cases */
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_MTU, mtu) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_GROUP, 0) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_TXQLEN, 0) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_NUM_TX_QUEUES, 0) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_NUM_RX_QUEUES, 0) >= 0);
|
||||
|
||||
assert_se(sd_netlink_call(rtnl, m, -1, &r) == 1);
|
||||
|
||||
assert_se(sd_netlink_message_read_string(r, IFLA_IFNAME, &str_data) == 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_u8(r, IFLA_CARRIER, &u8_data) == 0);
|
||||
assert_se(sd_netlink_message_read_u8(r, IFLA_OPERSTATE, &u8_data) == 0);
|
||||
assert_se(sd_netlink_message_read_u8(r, IFLA_LINKMODE, &u8_data) == 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_u32(r, IFLA_MTU, &u32_data) == 0);
|
||||
assert_se(sd_netlink_message_read_u32(r, IFLA_GROUP, &u32_data) == 0);
|
||||
assert_se(sd_netlink_message_read_u32(r, IFLA_TXQLEN, &u32_data) == 0);
|
||||
assert_se(sd_netlink_message_read_u32(r, IFLA_NUM_TX_QUEUES, &u32_data) == 0);
|
||||
assert_se(sd_netlink_message_read_u32(r, IFLA_NUM_RX_QUEUES, &u32_data) == 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_ether_addr(r, IFLA_ADDRESS, ð_data) == 0);
|
||||
|
||||
assert_se(sd_netlink_flush(rtnl) >= 0);
|
||||
assert_se((m = sd_netlink_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_netlink_message_unref(r)) == NULL);
|
||||
}
|
||||
|
||||
|
||||
static void test_address_get(sd_netlink *rtnl, int ifindex) {
|
||||
sd_netlink_message *m;
|
||||
sd_netlink_message *r;
|
||||
struct in_addr in_data;
|
||||
struct ifa_cacheinfo cache;
|
||||
const char *label;
|
||||
|
||||
assert_se(sd_rtnl_message_new_addr(rtnl, &m, RTM_GETADDR, ifindex, AF_INET) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
assert_se(sd_netlink_call(rtnl, m, -1, &r) == 1);
|
||||
|
||||
assert_se(sd_netlink_message_read_in_addr(r, IFA_LOCAL, &in_data) == 0);
|
||||
assert_se(sd_netlink_message_read_in_addr(r, IFA_ADDRESS, &in_data) == 0);
|
||||
assert_se(sd_netlink_message_read_string(r, IFA_LABEL, &label) == 0);
|
||||
assert_se(sd_netlink_message_read_cache_info(r, IFA_CACHEINFO, &cache) == 0);
|
||||
|
||||
assert_se(sd_netlink_flush(rtnl) >= 0);
|
||||
assert_se((m = sd_netlink_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_netlink_message_unref(r)) == NULL);
|
||||
|
||||
}
|
||||
|
||||
static void test_route(void) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req;
|
||||
struct in_addr addr, addr_data;
|
||||
uint32_t index = 2, u32_data;
|
||||
int r;
|
||||
|
||||
r = sd_rtnl_message_new_route(NULL, &req, RTM_NEWROUTE, AF_INET, RTPROT_STATIC);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "Could not create RTM_NEWROUTE message: %m");
|
||||
return;
|
||||
}
|
||||
|
||||
addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &addr);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
|
||||
return;
|
||||
}
|
||||
|
||||
r = sd_netlink_message_append_u32(req, RTA_OIF, index);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "Could not append RTA_OIF attribute: %m");
|
||||
return;
|
||||
}
|
||||
|
||||
assert_se(sd_netlink_message_rewind(req) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_in_addr(req, RTA_GATEWAY, &addr_data) >= 0);
|
||||
assert_se(addr_data.s_addr == addr.s_addr);
|
||||
|
||||
assert_se(sd_netlink_message_read_u32(req, RTA_OIF, &u32_data) >= 0);
|
||||
assert_se(u32_data == index);
|
||||
|
||||
assert_se((req = sd_netlink_message_unref(req)) == NULL);
|
||||
}
|
||||
|
||||
static void test_multiple(void) {
|
||||
sd_netlink *rtnl1, *rtnl2;
|
||||
|
||||
assert_se(sd_netlink_open(&rtnl1) >= 0);
|
||||
assert_se(sd_netlink_open(&rtnl2) >= 0);
|
||||
|
||||
rtnl1 = sd_netlink_unref(rtnl1);
|
||||
rtnl2 = sd_netlink_unref(rtnl2);
|
||||
}
|
||||
|
||||
static int link_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
char *ifname = userdata;
|
||||
const char *data;
|
||||
|
||||
assert_se(rtnl);
|
||||
assert_se(m);
|
||||
|
||||
log_info("got link info about %s", ifname);
|
||||
free(ifname);
|
||||
|
||||
assert_se(sd_netlink_message_read_string(m, IFLA_IFNAME, &data) >= 0);
|
||||
assert_se(streq(data, "lo"));
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void test_event_loop(int ifindex) {
|
||||
_cleanup_event_unref_ sd_event *event = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
char *ifname;
|
||||
|
||||
ifname = strdup("lo2");
|
||||
assert_se(ifname);
|
||||
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
|
||||
|
||||
assert_se(sd_netlink_call_async(rtnl, m, &link_handler, ifname, 0, NULL) >= 0);
|
||||
|
||||
assert_se(sd_event_default(&event) >= 0);
|
||||
|
||||
assert_se(sd_netlink_attach_event(rtnl, event, 0) >= 0);
|
||||
|
||||
assert_se(sd_event_run(event, 0) >= 0);
|
||||
|
||||
assert_se(sd_netlink_detach_event(rtnl) >= 0);
|
||||
|
||||
assert_se((rtnl = sd_netlink_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static int pipe_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
int *counter = userdata;
|
||||
int r;
|
||||
|
||||
(*counter) --;
|
||||
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
|
||||
log_info_errno(r, "%d left in pipe. got reply: %m", *counter);
|
||||
|
||||
assert_se(r >= 0);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void test_async(int ifindex) {
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL, *r = NULL;
|
||||
uint32_t serial;
|
||||
char *ifname;
|
||||
|
||||
ifname = strdup("lo");
|
||||
assert_se(ifname);
|
||||
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
|
||||
|
||||
assert_se(sd_netlink_call_async(rtnl, m, &link_handler, ifname, 0, &serial) >= 0);
|
||||
|
||||
assert_se(sd_netlink_wait(rtnl, 0) >= 0);
|
||||
assert_se(sd_netlink_process(rtnl, &r) >= 0);
|
||||
|
||||
assert_se((rtnl = sd_netlink_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static void test_pipe(int ifindex) {
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m1 = NULL, *m2 = NULL;
|
||||
int counter = 0;
|
||||
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m1, RTM_GETLINK, ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m2, RTM_GETLINK, ifindex) >= 0);
|
||||
|
||||
counter ++;
|
||||
assert_se(sd_netlink_call_async(rtnl, m1, &pipe_handler, &counter, 0, NULL) >= 0);
|
||||
|
||||
counter ++;
|
||||
assert_se(sd_netlink_call_async(rtnl, m2, &pipe_handler, &counter, 0, NULL) >= 0);
|
||||
|
||||
while (counter > 0) {
|
||||
assert_se(sd_netlink_wait(rtnl, 0) >= 0);
|
||||
assert_se(sd_netlink_process(rtnl, NULL) >= 0);
|
||||
}
|
||||
|
||||
assert_se((rtnl = sd_netlink_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static void test_container(void) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
uint16_t u16_data;
|
||||
uint32_t u32_data;
|
||||
const char *string_data;
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(NULL, &m, RTM_NEWLINK, 0) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_open_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "vlan") >= 0);
|
||||
assert_se(sd_netlink_message_append_u16(m, IFLA_VLAN_ID, 100) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_message_append_string(m, IFLA_INFO_KIND, "vlan") >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) == -EINVAL);
|
||||
|
||||
assert_se(sd_netlink_message_rewind(m) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_enter_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_netlink_message_read_string(m, IFLA_INFO_KIND, &string_data) >= 0);
|
||||
assert_se(streq("vlan", string_data));
|
||||
|
||||
assert_se(sd_netlink_message_enter_container(m, IFLA_INFO_DATA) >= 0);
|
||||
assert_se(sd_netlink_message_read_u16(m, IFLA_VLAN_ID, &u16_data) >= 0);
|
||||
assert_se(sd_netlink_message_exit_container(m) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_string(m, IFLA_INFO_KIND, &string_data) >= 0);
|
||||
assert_se(streq("vlan", string_data));
|
||||
assert_se(sd_netlink_message_exit_container(m) >= 0);
|
||||
|
||||
assert_se(sd_netlink_message_read_u32(m, IFLA_LINKINFO, &u32_data) < 0);
|
||||
|
||||
assert_se(sd_netlink_message_exit_container(m) == -EINVAL);
|
||||
}
|
||||
|
||||
static void test_match(void) {
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
|
||||
assert_se(sd_netlink_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
|
||||
assert_se(sd_netlink_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
|
||||
|
||||
assert_se(sd_netlink_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 1);
|
||||
assert_se(sd_netlink_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 1);
|
||||
assert_se(sd_netlink_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 0);
|
||||
|
||||
assert_se((rtnl = sd_netlink_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static void test_get_addresses(sd_netlink *rtnl) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
sd_netlink_message *m;
|
||||
|
||||
assert_se(sd_rtnl_message_new_addr(rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC) >= 0);
|
||||
|
||||
assert_se(sd_netlink_call(rtnl, req, 0, &reply) >= 0);
|
||||
|
||||
for (m = reply; m; m = sd_netlink_message_next(m)) {
|
||||
uint16_t type;
|
||||
unsigned char scope, flags;
|
||||
int family, ifindex;
|
||||
|
||||
assert_se(sd_netlink_message_get_type(m, &type) >= 0);
|
||||
assert_se(type == RTM_NEWADDR);
|
||||
|
||||
assert_se(sd_rtnl_message_addr_get_ifindex(m, &ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_addr_get_family(m, &family) >= 0);
|
||||
assert_se(sd_rtnl_message_addr_get_scope(m, &scope) >= 0);
|
||||
assert_se(sd_rtnl_message_addr_get_flags(m, &flags) >= 0);
|
||||
|
||||
assert_se(ifindex > 0);
|
||||
assert_se(family == AF_INET || family == AF_INET6);
|
||||
|
||||
log_info("got IPv%u address on ifindex %i", family == AF_INET ? 4: 6, ifindex);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_message(void) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
|
||||
assert_se(rtnl_message_new_synthetic_error(-ETIMEDOUT, 1, &m) >= 0);
|
||||
assert_se(sd_netlink_message_get_errno(m) == -ETIMEDOUT);
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
sd_netlink *rtnl;
|
||||
sd_netlink_message *m;
|
||||
sd_netlink_message *r;
|
||||
const char *string_data;
|
||||
int if_loopback;
|
||||
uint16_t type;
|
||||
|
||||
test_message();
|
||||
|
||||
test_match();
|
||||
|
||||
test_multiple();
|
||||
|
||||
test_route();
|
||||
|
||||
test_container();
|
||||
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
assert_se(rtnl);
|
||||
|
||||
if_loopback = (int) if_nametoindex("lo");
|
||||
assert_se(if_loopback > 0);
|
||||
|
||||
test_async(if_loopback);
|
||||
|
||||
test_pipe(if_loopback);
|
||||
|
||||
test_event_loop(if_loopback);
|
||||
|
||||
test_link_configure(rtnl, if_loopback);
|
||||
|
||||
test_get_addresses(rtnl);
|
||||
|
||||
test_message_link_bridge(rtnl);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
assert_se(sd_netlink_message_get_type(m, &type) >= 0);
|
||||
assert_se(type == RTM_GETLINK);
|
||||
|
||||
assert_se(sd_netlink_message_read_string(m, IFLA_IFNAME, &string_data) == -EPERM);
|
||||
|
||||
assert_se(sd_netlink_call(rtnl, m, 0, &r) == 1);
|
||||
assert_se(sd_netlink_message_get_type(r, &type) >= 0);
|
||||
assert_se(type == RTM_NEWLINK);
|
||||
|
||||
assert_se((r = sd_netlink_message_unref(r)) == NULL);
|
||||
|
||||
assert_se(sd_netlink_call(rtnl, m, -1, &r) == -EPERM);
|
||||
assert_se((m = sd_netlink_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_netlink_message_unref(r)) == NULL);
|
||||
|
||||
test_link_get(rtnl, if_loopback);
|
||||
test_address_get(rtnl, if_loopback);
|
||||
|
||||
assert_se(sd_netlink_flush(rtnl) >= 0);
|
||||
assert_se((m = sd_netlink_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_netlink_message_unref(r)) == NULL);
|
||||
assert_se((rtnl = sd_netlink_unref(rtnl)) == NULL);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
@ -1,443 +0,0 @@
|
||||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
||||
|
||||
/***
|
||||
This file is part of systemd.
|
||||
|
||||
Copyright 2013 Tom Gundersen <teg@jklm.no>
|
||||
|
||||
systemd 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.
|
||||
|
||||
systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
|
||||
***/
|
||||
|
||||
#include <netinet/ether.h>
|
||||
#include <net/if.h>
|
||||
|
||||
#include "util.h"
|
||||
#include "macro.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "socket-util.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "event-util.h"
|
||||
#include "missing.h"
|
||||
|
||||
static void test_message_link_bridge(sd_rtnl *rtnl) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL;
|
||||
uint32_t cost;
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_NEWLINK, 1) >= 0);
|
||||
assert_se(sd_rtnl_message_link_set_family(message, PF_BRIDGE) >= 0);
|
||||
assert_se(sd_rtnl_message_open_container(message, IFLA_PROTINFO) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(message, IFLA_BRPORT_COST, 10) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(message) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_rewind(message) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_enter_container(message, IFLA_PROTINFO) >= 0);
|
||||
assert_se(sd_rtnl_message_read_u32(message, IFLA_BRPORT_COST, &cost) >= 0);
|
||||
assert_se(cost == 10);
|
||||
assert_se(sd_rtnl_message_exit_container(message) >= 0);
|
||||
}
|
||||
|
||||
static void test_link_configure(sd_rtnl *rtnl, int ifindex) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *message = NULL;
|
||||
const char *mac = "98:fe:94:3f:c6:18", *name = "test";
|
||||
char buffer[ETHER_ADDR_TO_STRING_MAX];
|
||||
unsigned int mtu = 1450, mtu_out;
|
||||
const char *name_out;
|
||||
struct ether_addr mac_out;
|
||||
|
||||
/* we'd really like to test NEWLINK, but let's not mess with the running kernel */
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &message, RTM_GETLINK, ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_append_string(message, IFLA_IFNAME, name) >= 0);
|
||||
assert_se(sd_rtnl_message_append_ether_addr(message, IFLA_ADDRESS, ether_aton(mac)) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(message, IFLA_MTU, mtu) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, message, 0, NULL) == 1);
|
||||
assert_se(sd_rtnl_message_rewind(message) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_string(message, IFLA_IFNAME, &name_out) >= 0);
|
||||
assert_se(streq(name, name_out));
|
||||
|
||||
assert_se(sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &mac_out) >= 0);
|
||||
assert_se(streq(mac, ether_addr_to_string(&mac_out, buffer)));
|
||||
|
||||
assert_se(sd_rtnl_message_read_u32(message, IFLA_MTU, &mtu_out) >= 0);
|
||||
assert_se(mtu == mtu_out);
|
||||
}
|
||||
|
||||
static void test_link_get(sd_rtnl *rtnl, int ifindex) {
|
||||
sd_rtnl_message *m;
|
||||
sd_rtnl_message *r;
|
||||
unsigned int mtu = 1500;
|
||||
const char *str_data;
|
||||
uint8_t u8_data;
|
||||
uint32_t u32_data;
|
||||
struct ether_addr eth_data;
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
/* u8 test cases */
|
||||
assert_se(sd_rtnl_message_append_u8(m, IFLA_CARRIER, 0) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u8(m, IFLA_OPERSTATE, 0) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u8(m, IFLA_LINKMODE, 0) >= 0);
|
||||
|
||||
/* u32 test cases */
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_MTU, mtu) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_GROUP, 0) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_TXQLEN, 0) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_NUM_TX_QUEUES, 0) >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_NUM_RX_QUEUES, 0) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, m, -1, &r) == 1);
|
||||
|
||||
assert_se(sd_rtnl_message_read_string(r, IFLA_IFNAME, &str_data) == 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_u8(r, IFLA_CARRIER, &u8_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_u8(r, IFLA_OPERSTATE, &u8_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_u8(r, IFLA_LINKMODE, &u8_data) == 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_u32(r, IFLA_MTU, &u32_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_u32(r, IFLA_GROUP, &u32_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_u32(r, IFLA_TXQLEN, &u32_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_u32(r, IFLA_NUM_TX_QUEUES, &u32_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_u32(r, IFLA_NUM_RX_QUEUES, &u32_data) == 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_ether_addr(r, IFLA_ADDRESS, ð_data) == 0);
|
||||
|
||||
assert_se(sd_rtnl_flush(rtnl) >= 0);
|
||||
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
|
||||
}
|
||||
|
||||
|
||||
static void test_address_get(sd_rtnl *rtnl, int ifindex) {
|
||||
sd_rtnl_message *m;
|
||||
sd_rtnl_message *r;
|
||||
struct in_addr in_data;
|
||||
struct ifa_cacheinfo cache;
|
||||
const char *label;
|
||||
|
||||
assert_se(sd_rtnl_message_new_addr(rtnl, &m, RTM_GETADDR, ifindex, AF_INET) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, m, -1, &r) == 1);
|
||||
|
||||
assert_se(sd_rtnl_message_read_in_addr(r, IFA_LOCAL, &in_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_in_addr(r, IFA_ADDRESS, &in_data) == 0);
|
||||
assert_se(sd_rtnl_message_read_string(r, IFA_LABEL, &label) == 0);
|
||||
assert_se(sd_rtnl_message_read_cache_info(r, IFA_CACHEINFO, &cache) == 0);
|
||||
|
||||
assert_se(sd_rtnl_flush(rtnl) >= 0);
|
||||
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
|
||||
|
||||
}
|
||||
|
||||
static void test_route(void) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req;
|
||||
struct in_addr addr, addr_data;
|
||||
uint32_t index = 2, u32_data;
|
||||
int r;
|
||||
|
||||
r = sd_rtnl_message_new_route(NULL, &req, RTM_NEWROUTE, AF_INET, RTPROT_STATIC);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "Could not create RTM_NEWROUTE message: %m");
|
||||
return;
|
||||
}
|
||||
|
||||
addr.s_addr = htonl(INADDR_LOOPBACK);
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_GATEWAY, &addr);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
|
||||
return;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, RTA_OIF, index);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "Could not append RTA_OIF attribute: %m");
|
||||
return;
|
||||
}
|
||||
|
||||
assert_se(sd_rtnl_message_rewind(req) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_in_addr(req, RTA_GATEWAY, &addr_data) >= 0);
|
||||
assert_se(addr_data.s_addr == addr.s_addr);
|
||||
|
||||
assert_se(sd_rtnl_message_read_u32(req, RTA_OIF, &u32_data) >= 0);
|
||||
assert_se(u32_data == index);
|
||||
|
||||
assert_se((req = sd_rtnl_message_unref(req)) == NULL);
|
||||
}
|
||||
|
||||
static void test_multiple(void) {
|
||||
sd_rtnl *rtnl1, *rtnl2;
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl1) >= 0);
|
||||
assert_se(sd_rtnl_open(&rtnl2) >= 0);
|
||||
|
||||
rtnl1 = sd_rtnl_unref(rtnl1);
|
||||
rtnl2 = sd_rtnl_unref(rtnl2);
|
||||
}
|
||||
|
||||
static int link_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
char *ifname = userdata;
|
||||
const char *data;
|
||||
|
||||
assert_se(rtnl);
|
||||
assert_se(m);
|
||||
|
||||
log_info("got link info about %s", ifname);
|
||||
free(ifname);
|
||||
|
||||
assert_se(sd_rtnl_message_read_string(m, IFLA_IFNAME, &data) >= 0);
|
||||
assert_se(streq(data, "lo"));
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void test_event_loop(int ifindex) {
|
||||
_cleanup_event_unref_ sd_event *event = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
char *ifname;
|
||||
|
||||
ifname = strdup("lo2");
|
||||
assert_se(ifname);
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, NULL) >= 0);
|
||||
|
||||
assert_se(sd_event_default(&event) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_attach_event(rtnl, event, 0) >= 0);
|
||||
|
||||
assert_se(sd_event_run(event, 0) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_detach_event(rtnl) >= 0);
|
||||
|
||||
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static int pipe_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
int *counter = userdata;
|
||||
int r;
|
||||
|
||||
(*counter) --;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
|
||||
log_info_errno(r, "%d left in pipe. got reply: %m", *counter);
|
||||
|
||||
assert_se(r >= 0);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void test_async(int ifindex) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL, *r = NULL;
|
||||
uint32_t serial;
|
||||
char *ifname;
|
||||
|
||||
ifname = strdup("lo");
|
||||
assert_se(ifname);
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, ifindex) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call_async(rtnl, m, &link_handler, ifname, 0, &serial) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_wait(rtnl, 0) >= 0);
|
||||
assert_se(sd_rtnl_process(rtnl, &r) >= 0);
|
||||
|
||||
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static void test_pipe(int ifindex) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m1 = NULL, *m2 = NULL;
|
||||
int counter = 0;
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m1, RTM_GETLINK, ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m2, RTM_GETLINK, ifindex) >= 0);
|
||||
|
||||
counter ++;
|
||||
assert_se(sd_rtnl_call_async(rtnl, m1, &pipe_handler, &counter, 0, NULL) >= 0);
|
||||
|
||||
counter ++;
|
||||
assert_se(sd_rtnl_call_async(rtnl, m2, &pipe_handler, &counter, 0, NULL) >= 0);
|
||||
|
||||
while (counter > 0) {
|
||||
assert_se(sd_rtnl_wait(rtnl, 0) >= 0);
|
||||
assert_se(sd_rtnl_process(rtnl, NULL) >= 0);
|
||||
}
|
||||
|
||||
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static void test_container(void) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
uint16_t u16_data;
|
||||
uint32_t u32_data;
|
||||
const char *string_data;
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(NULL, &m, RTM_NEWLINK, 0) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "vlan") >= 0);
|
||||
assert_se(sd_rtnl_message_append_u16(m, IFLA_VLAN_ID, 100) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_rtnl_message_append_string(m, IFLA_INFO_KIND, "vlan") >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) == -EINVAL);
|
||||
|
||||
assert_se(sd_rtnl_message_rewind(m) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_enter_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_rtnl_message_read_string(m, IFLA_INFO_KIND, &string_data) >= 0);
|
||||
assert_se(streq("vlan", string_data));
|
||||
|
||||
assert_se(sd_rtnl_message_enter_container(m, IFLA_INFO_DATA) >= 0);
|
||||
assert_se(sd_rtnl_message_read_u16(m, IFLA_VLAN_ID, &u16_data) >= 0);
|
||||
assert_se(sd_rtnl_message_exit_container(m) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_string(m, IFLA_INFO_KIND, &string_data) >= 0);
|
||||
assert_se(streq("vlan", string_data));
|
||||
assert_se(sd_rtnl_message_exit_container(m) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_read_u32(m, IFLA_LINKINFO, &u32_data) < 0);
|
||||
|
||||
assert_se(sd_rtnl_message_exit_container(m) == -EINVAL);
|
||||
}
|
||||
|
||||
static void test_match(void) {
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
|
||||
assert_se(sd_rtnl_add_match(rtnl, RTM_NEWLINK, &link_handler, NULL) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 1);
|
||||
assert_se(sd_rtnl_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 1);
|
||||
assert_se(sd_rtnl_remove_match(rtnl, RTM_NEWLINK, &link_handler, NULL) == 0);
|
||||
|
||||
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
|
||||
}
|
||||
|
||||
static void test_get_addresses(sd_rtnl *rtnl) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
sd_rtnl_message *m;
|
||||
|
||||
assert_se(sd_rtnl_message_new_addr(rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, req, 0, &reply) >= 0);
|
||||
|
||||
for (m = reply; m; m = sd_rtnl_message_next(m)) {
|
||||
uint16_t type;
|
||||
unsigned char scope, flags;
|
||||
int family, ifindex;
|
||||
|
||||
assert_se(sd_rtnl_message_get_type(m, &type) >= 0);
|
||||
assert_se(type == RTM_NEWADDR);
|
||||
|
||||
assert_se(sd_rtnl_message_addr_get_ifindex(m, &ifindex) >= 0);
|
||||
assert_se(sd_rtnl_message_addr_get_family(m, &family) >= 0);
|
||||
assert_se(sd_rtnl_message_addr_get_scope(m, &scope) >= 0);
|
||||
assert_se(sd_rtnl_message_addr_get_flags(m, &flags) >= 0);
|
||||
|
||||
assert_se(ifindex > 0);
|
||||
assert_se(family == AF_INET || family == AF_INET6);
|
||||
|
||||
log_info("got IPv%u address on ifindex %i", family == AF_INET ? 4: 6, ifindex);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_message(void) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
|
||||
assert_se(rtnl_message_new_synthetic_error(-ETIMEDOUT, 1, &m) >= 0);
|
||||
assert_se(sd_rtnl_message_get_errno(m) == -ETIMEDOUT);
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
sd_rtnl *rtnl;
|
||||
sd_rtnl_message *m;
|
||||
sd_rtnl_message *r;
|
||||
const char *string_data;
|
||||
int if_loopback;
|
||||
uint16_t type;
|
||||
|
||||
test_message();
|
||||
|
||||
test_match();
|
||||
|
||||
test_multiple();
|
||||
|
||||
test_route();
|
||||
|
||||
test_container();
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
assert_se(rtnl);
|
||||
|
||||
if_loopback = (int) if_nametoindex("lo");
|
||||
assert_se(if_loopback > 0);
|
||||
|
||||
test_async(if_loopback);
|
||||
|
||||
test_pipe(if_loopback);
|
||||
|
||||
test_event_loop(if_loopback);
|
||||
|
||||
test_link_configure(rtnl, if_loopback);
|
||||
|
||||
test_get_addresses(rtnl);
|
||||
|
||||
test_message_link_bridge(rtnl);
|
||||
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
assert_se(sd_rtnl_message_get_type(m, &type) >= 0);
|
||||
assert_se(type == RTM_GETLINK);
|
||||
|
||||
assert_se(sd_rtnl_message_read_string(m, IFLA_IFNAME, &string_data) == -EPERM);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, m, 0, &r) == 1);
|
||||
assert_se(sd_rtnl_message_get_type(r, &type) >= 0);
|
||||
assert_se(type == RTM_NEWLINK);
|
||||
|
||||
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, m, -1, &r) == -EPERM);
|
||||
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
|
||||
|
||||
test_link_get(rtnl, if_loopback);
|
||||
test_address_get(rtnl, if_loopback);
|
||||
|
||||
assert_se(sd_rtnl_flush(rtnl) >= 0);
|
||||
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
|
||||
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
|
||||
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
@ -24,7 +24,7 @@
|
||||
#include <net/if.h>
|
||||
|
||||
#include "sd-network.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "sd-hwdb.h"
|
||||
#include "sd-device.h"
|
||||
|
||||
@ -33,7 +33,7 @@
|
||||
#include "util.h"
|
||||
#include "pager.h"
|
||||
#include "lldp.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "device-util.h"
|
||||
#include "hwdb-util.h"
|
||||
#include "arphrd-list.h"
|
||||
@ -112,19 +112,19 @@ static int link_info_compare(const void *a, const void *b) {
|
||||
return x->ifindex - y->ifindex;
|
||||
}
|
||||
|
||||
static int decode_and_sort_links(sd_rtnl_message *m, LinkInfo **ret) {
|
||||
static int decode_and_sort_links(sd_netlink_message *m, LinkInfo **ret) {
|
||||
_cleanup_free_ LinkInfo *links = NULL;
|
||||
size_t size = 0, c = 0;
|
||||
sd_rtnl_message *i;
|
||||
sd_netlink_message *i;
|
||||
int r;
|
||||
|
||||
for (i = m; i; i = sd_rtnl_message_next(i)) {
|
||||
for (i = m; i; i = sd_netlink_message_next(i)) {
|
||||
const char *name;
|
||||
unsigned iftype;
|
||||
uint16_t type;
|
||||
int ifindex;
|
||||
|
||||
r = sd_rtnl_message_get_type(i, &type);
|
||||
r = sd_netlink_message_get_type(i, &type);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -135,7 +135,7 @@ static int decode_and_sort_links(sd_rtnl_message *m, LinkInfo **ret) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_read_string(i, IFLA_IFNAME, &name);
|
||||
r = sd_netlink_message_read_string(i, IFLA_IFNAME, &name);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -192,14 +192,14 @@ static void setup_state_to_color(const char *state, const char **on, const char
|
||||
}
|
||||
|
||||
static int list_links(int argc, char *argv[], void *userdata) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_free_ LinkInfo *links = NULL;
|
||||
int r, c, i;
|
||||
|
||||
pager_open_if_enabled();
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -207,11 +207,11 @@ static int list_links(int argc, char *argv[], void *userdata) {
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to enumerate links: %m");
|
||||
|
||||
@ -287,14 +287,14 @@ static int ieee_oui(sd_hwdb *hwdb, struct ether_addr *mac, char **ret) {
|
||||
}
|
||||
|
||||
static int get_gateway_description(
|
||||
sd_rtnl *rtnl,
|
||||
sd_netlink *rtnl,
|
||||
sd_hwdb *hwdb,
|
||||
int ifindex,
|
||||
int family,
|
||||
union in_addr_union *gateway,
|
||||
char **gateway_description) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
sd_rtnl_message *m;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
sd_netlink_message *m;
|
||||
int r;
|
||||
|
||||
assert(rtnl);
|
||||
@ -307,27 +307,27 @@ static int get_gateway_description(
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (m = reply; m; m = sd_rtnl_message_next(m)) {
|
||||
for (m = reply; m; m = sd_netlink_message_next(m)) {
|
||||
union in_addr_union gw = {};
|
||||
struct ether_addr mac = {};
|
||||
uint16_t type;
|
||||
int ifi, fam;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "got error: %m");
|
||||
continue;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_get_type(m, &type);
|
||||
r = sd_netlink_message_get_type(m, &type);
|
||||
if (r < 0) {
|
||||
log_error_errno(r, "could not get type: %m");
|
||||
continue;
|
||||
@ -360,13 +360,13 @@ static int get_gateway_description(
|
||||
|
||||
switch (fam) {
|
||||
case AF_INET:
|
||||
r = sd_rtnl_message_read_in_addr(m, NDA_DST, &gw.in);
|
||||
r = sd_netlink_message_read_in_addr(m, NDA_DST, &gw.in);
|
||||
if (r < 0)
|
||||
continue;
|
||||
|
||||
break;
|
||||
case AF_INET6:
|
||||
r = sd_rtnl_message_read_in6_addr(m, NDA_DST, &gw.in6);
|
||||
r = sd_netlink_message_read_in6_addr(m, NDA_DST, &gw.in6);
|
||||
if (r < 0)
|
||||
continue;
|
||||
|
||||
@ -378,7 +378,7 @@ static int get_gateway_description(
|
||||
if (!in_addr_equal(fam, &gw, gateway))
|
||||
continue;
|
||||
|
||||
r = sd_rtnl_message_read_ether_addr(m, NDA_LLADDR, &mac);
|
||||
r = sd_netlink_message_read_ether_addr(m, NDA_LLADDR, &mac);
|
||||
if (r < 0)
|
||||
continue;
|
||||
|
||||
@ -393,7 +393,7 @@ static int get_gateway_description(
|
||||
}
|
||||
|
||||
static int dump_gateways(
|
||||
sd_rtnl *rtnl,
|
||||
sd_netlink *rtnl,
|
||||
sd_hwdb *hwdb,
|
||||
const char *prefix,
|
||||
int ifindex) {
|
||||
@ -442,7 +442,7 @@ static int dump_gateways(
|
||||
}
|
||||
|
||||
static int dump_addresses(
|
||||
sd_rtnl *rtnl,
|
||||
sd_netlink *rtnl,
|
||||
const char *prefix,
|
||||
int ifindex) {
|
||||
|
||||
@ -493,12 +493,12 @@ static void dump_list(const char *prefix, char **l) {
|
||||
}
|
||||
|
||||
static int link_status_one(
|
||||
sd_rtnl *rtnl,
|
||||
sd_netlink *rtnl,
|
||||
sd_hwdb *hwdb,
|
||||
const char *name) {
|
||||
_cleanup_strv_free_ char **dns = NULL, **ntp = NULL, **domains = NULL;
|
||||
_cleanup_free_ char *setup_state = NULL, *operational_state = NULL;
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
_cleanup_device_unref_ sd_device *d = NULL;
|
||||
char devid[2 + DECIMAL_STR_MAX(int)];
|
||||
_cleanup_free_ char *t = NULL, *network = NULL;
|
||||
@ -523,13 +523,13 @@ static int link_status_one(
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_message_append_string(req, IFLA_IFNAME, name);
|
||||
r = sd_netlink_message_append_string(req, IFLA_IFNAME, name);
|
||||
}
|
||||
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to query link: %m");
|
||||
|
||||
@ -537,7 +537,7 @@ static int link_status_one(
|
||||
if (r < 0)
|
||||
return rtnl_log_parse_error(r);
|
||||
|
||||
r = sd_rtnl_message_read_string(reply, IFLA_IFNAME, &name);
|
||||
r = sd_netlink_message_read_string(reply, IFLA_IFNAME, &name);
|
||||
if (r < 0)
|
||||
return rtnl_log_parse_error(r);
|
||||
|
||||
@ -545,7 +545,7 @@ static int link_status_one(
|
||||
if (r < 0)
|
||||
return rtnl_log_parse_error(r);
|
||||
|
||||
have_mac = sd_rtnl_message_read_ether_addr(reply, IFLA_ADDRESS, &e) >= 0;
|
||||
have_mac = sd_netlink_message_read_ether_addr(reply, IFLA_ADDRESS, &e) >= 0;
|
||||
|
||||
if (have_mac) {
|
||||
const uint8_t *p;
|
||||
@ -561,7 +561,7 @@ static int link_status_one(
|
||||
have_mac = false;
|
||||
}
|
||||
|
||||
sd_rtnl_message_read_u32(reply, IFLA_MTU, &mtu);
|
||||
sd_netlink_message_read_u32(reply, IFLA_MTU, &mtu);
|
||||
|
||||
sd_network_link_get_operational_state(ifindex, &operational_state);
|
||||
operational_state_to_color(operational_state, &on_color_operational, &off_color_operational);
|
||||
@ -666,11 +666,11 @@ static int link_status_one(
|
||||
|
||||
static int link_status(int argc, char *argv[], void *userdata) {
|
||||
_cleanup_hwdb_unref_ sd_hwdb *hwdb = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
char **name;
|
||||
int r;
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -711,7 +711,7 @@ static int link_status(int argc, char *argv[], void *userdata) {
|
||||
pager_open_if_enabled();
|
||||
|
||||
if (arg_all) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
_cleanup_free_ LinkInfo *links = NULL;
|
||||
int c, i;
|
||||
|
||||
@ -719,11 +719,11 @@ static int link_status(int argc, char *argv[], void *userdata) {
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to enumerate links: %m");
|
||||
|
||||
@ -897,8 +897,8 @@ static char *lldp_system_caps(uint16_t cap) {
|
||||
}
|
||||
|
||||
static int link_lldp_status(int argc, char *argv[], void *userdata) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
_cleanup_free_ LinkInfo *links = NULL;
|
||||
const char *state, *word;
|
||||
|
||||
@ -910,7 +910,7 @@ static int link_lldp_status(int argc, char *argv[], void *userdata) {
|
||||
|
||||
pager_open_if_enabled();
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -918,11 +918,11 @@ static int link_lldp_status(int argc, char *argv[], void *userdata) {
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_call(rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to enumerate links: %m");
|
||||
|
||||
|
@ -151,8 +151,8 @@ int address_release(Address *address, Link *link) {
|
||||
}
|
||||
|
||||
int address_drop(Address *address, Link *link,
|
||||
sd_rtnl_message_handler_t callback) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
sd_netlink_message_handler_t callback) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(address);
|
||||
@ -174,13 +174,13 @@ int address_drop(Address *address, Link *link,
|
||||
return log_error_errno(r, "Could not set prefixlen: %m");
|
||||
|
||||
if (address->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
|
||||
else if (address->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -190,8 +190,8 @@ int address_drop(Address *address, Link *link,
|
||||
}
|
||||
|
||||
int address_update(Address *address, Link *link,
|
||||
sd_rtnl_message_handler_t callback) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
sd_netlink_message_handler_t callback) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(address);
|
||||
@ -216,7 +216,7 @@ int address_update(Address *address, Link *link,
|
||||
return log_error_errno(r, "Could not set flags: %m");
|
||||
|
||||
if (address->flags & ~0xff && link->rtnl_extended_attrs) {
|
||||
r = sd_rtnl_message_append_u32(req, IFA_FLAGS, address->flags);
|
||||
r = sd_netlink_message_append_u32(req, IFA_FLAGS, address->flags);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not set extended flags: %m");
|
||||
}
|
||||
@ -226,29 +226,29 @@ int address_update(Address *address, Link *link,
|
||||
return log_error_errno(r, "Could not set scope: %m");
|
||||
|
||||
if (address->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
|
||||
else if (address->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_LOCAL attribute: %m");
|
||||
|
||||
if (address->family == AF_INET) {
|
||||
r = sd_rtnl_message_append_in_addr(req, IFA_BROADCAST, &address->broadcast);
|
||||
r = sd_netlink_message_append_in_addr(req, IFA_BROADCAST, &address->broadcast);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_BROADCAST attribute: %m");
|
||||
}
|
||||
|
||||
if (address->label) {
|
||||
r = sd_rtnl_message_append_string(req, IFA_LABEL, address->label);
|
||||
r = sd_netlink_message_append_string(req, IFA_LABEL, address->label);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_LABEL attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_cache_info(req, IFA_CACHEINFO, &address->cinfo);
|
||||
r = sd_netlink_message_append_cache_info(req, IFA_CACHEINFO, &address->cinfo);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_CACHEINFO attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -317,8 +317,8 @@ static int address_acquire(Link *link, Address *original, Address **ret) {
|
||||
}
|
||||
|
||||
int address_configure(Address *address, Link *link,
|
||||
sd_rtnl_message_handler_t callback) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
sd_netlink_message_handler_t callback) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(address);
|
||||
@ -348,7 +348,7 @@ int address_configure(Address *address, Link *link,
|
||||
return log_error_errno(r, "Could not set flags: %m");
|
||||
|
||||
if (address->flags & ~0xff) {
|
||||
r = sd_rtnl_message_append_u32(req, IFA_FLAGS, address->flags);
|
||||
r = sd_netlink_message_append_u32(req, IFA_FLAGS, address->flags);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not set extended flags: %m");
|
||||
}
|
||||
@ -358,39 +358,39 @@ int address_configure(Address *address, Link *link,
|
||||
return log_error_errno(r, "Could not set scope: %m");
|
||||
|
||||
if (address->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, IFA_LOCAL, &address->in_addr.in);
|
||||
else if (address->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, IFA_LOCAL, &address->in_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_LOCAL attribute: %m");
|
||||
|
||||
if (!in_addr_is_null(address->family, &address->in_addr_peer)) {
|
||||
if (address->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, IFA_ADDRESS, &address->in_addr_peer.in);
|
||||
r = sd_netlink_message_append_in_addr(req, IFA_ADDRESS, &address->in_addr_peer.in);
|
||||
else if (address->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, IFA_ADDRESS, &address->in_addr_peer.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, IFA_ADDRESS, &address->in_addr_peer.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_ADDRESS attribute: %m");
|
||||
} else {
|
||||
if (address->family == AF_INET) {
|
||||
r = sd_rtnl_message_append_in_addr(req, IFA_BROADCAST, &address->broadcast);
|
||||
r = sd_netlink_message_append_in_addr(req, IFA_BROADCAST, &address->broadcast);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_BROADCAST attribute: %m");
|
||||
}
|
||||
}
|
||||
|
||||
if (address->label) {
|
||||
r = sd_rtnl_message_append_string(req, IFA_LABEL, address->label);
|
||||
r = sd_netlink_message_append_string(req, IFA_LABEL, address->label);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_LABEL attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_cache_info(req, IFA_CACHEINFO,
|
||||
r = sd_netlink_message_append_cache_info(req, IFA_CACHEINFO,
|
||||
&address->cinfo);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append IFA_CACHEINFO attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not send rtnetlink message: %m");
|
||||
|
||||
|
@ -27,7 +27,7 @@
|
||||
#include "network-internal.h"
|
||||
#include "dhcp-lease-internal.h"
|
||||
|
||||
static int dhcp4_route_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
static int dhcp4_route_handler(sd_netlink *rtnl, sd_netlink_message *m,
|
||||
void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
@ -37,7 +37,7 @@ static int dhcp4_route_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
|
||||
link->dhcp4_messages --;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
log_link_error(link, "could not set DHCPv4 route: %s",
|
||||
strerror(-r));
|
||||
@ -285,14 +285,14 @@ static int dhcp_lease_lost(Link *link) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dhcp4_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
static int dhcp4_address_handler(sd_netlink *rtnl, sd_netlink_message *m,
|
||||
void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
log_link_error(link, "could not set DHCPv4 address: %s",
|
||||
strerror(-r));
|
||||
|
@ -35,14 +35,14 @@ static int dhcp6_lease_information_acquired(sd_dhcp6_client *client,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dhcp6_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
static int dhcp6_address_handler(sd_netlink *rtnl, sd_netlink_message *m,
|
||||
void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
if (link->rtnl_extended_attrs) {
|
||||
log_link_warning(link, "Could not set extended netlink attributes, reverting to fallback mechanism");
|
||||
|
@ -80,13 +80,13 @@ int fdb_entry_new_static(Network *const network,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_fdb_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int set_fdb_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
Link *link = userdata;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST)
|
||||
log_link_error_errno(link, r, "Could not add FDB entry: %m");
|
||||
|
||||
@ -95,8 +95,8 @@ static int set_fdb_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
|
||||
/* send a request to the kernel to add a FDB entry in its static MAC table. */
|
||||
int fdb_entry_configure(Link *const link, FdbEntry *const fdb_entry) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
sd_rtnl *rtnl;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
sd_netlink *rtnl;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -120,19 +120,19 @@ int fdb_entry_configure(Link *const link, FdbEntry *const fdb_entry) {
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
r = sd_rtnl_message_append_ether_addr(req, NDA_LLADDR, fdb_entry->mac_addr);
|
||||
r = sd_netlink_message_append_ether_addr(req, NDA_LLADDR, fdb_entry->mac_addr);
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
|
||||
/* VLAN Id is optional. We'll add VLAN Id only if it's specified. */
|
||||
if (0 != fdb_entry->vlan_id) {
|
||||
r = sd_rtnl_message_append_u16(req, NDA_VLAN, fdb_entry->vlan_id);
|
||||
r = sd_netlink_message_append_u16(req, NDA_VLAN, fdb_entry->vlan_id);
|
||||
if (r < 0)
|
||||
return rtnl_log_create_error(r);
|
||||
}
|
||||
|
||||
/* send message to the kernel to update its internal static MAC table. */
|
||||
r = sd_rtnl_call_async(rtnl, req, set_fdb_handler, link, 0, NULL);
|
||||
r = sd_netlink_call_async(rtnl, req, set_fdb_handler, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
|
@ -73,14 +73,14 @@ static int ipv4ll_address_lost(Link *link) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ipv4ll_route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int ipv4ll_route_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
assert(!link->ipv4ll_route);
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
log_link_error(link, "could not set ipv4ll route: %s", strerror(-r));
|
||||
link_enter_failed(link);
|
||||
@ -94,14 +94,14 @@ static int ipv4ll_route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdat
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ipv4ll_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int ipv4ll_address_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
assert(!link->ipv4ll_address);
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
log_link_error(link, "could not set ipv4ll address: %s", strerror(-r));
|
||||
link_enter_failed(link);
|
||||
|
@ -121,7 +121,7 @@ static bool link_ipv6_forward_enabled(Link *link) {
|
||||
? ((old & flag) ? (" -" string) : (" +" string)) \
|
||||
: "")
|
||||
|
||||
static int link_update_flags(Link *link, sd_rtnl_message *m) {
|
||||
static int link_update_flags(Link *link, sd_netlink_message *m) {
|
||||
unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
|
||||
uint8_t operstate;
|
||||
int r;
|
||||
@ -132,7 +132,7 @@ static int link_update_flags(Link *link, sd_rtnl_message *m) {
|
||||
if (r < 0)
|
||||
return log_link_warning_errno(link, r, "Could not get link flags: %m");
|
||||
|
||||
r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
|
||||
r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
|
||||
if (r < 0)
|
||||
/* if we got a message without operstate, take it to mean
|
||||
the state was unchanged */
|
||||
@ -193,7 +193,7 @@ static int link_update_flags(Link *link, sd_rtnl_message *m) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
|
||||
static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
|
||||
_cleanup_link_unref_ Link *link = NULL;
|
||||
uint16_t type;
|
||||
const char *ifname;
|
||||
@ -203,7 +203,7 @@ static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
|
||||
assert(message);
|
||||
assert(ret);
|
||||
|
||||
r = sd_rtnl_message_get_type(message, &type);
|
||||
r = sd_netlink_message_get_type(message, &type);
|
||||
if (r < 0)
|
||||
return r;
|
||||
else if (type != RTM_NEWLINK)
|
||||
@ -215,7 +215,7 @@ static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
|
||||
else if (ifindex <= 0)
|
||||
return -EINVAL;
|
||||
|
||||
r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
|
||||
r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -232,7 +232,7 @@ static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
|
||||
if (!link->ifname)
|
||||
return -ENOMEM;
|
||||
|
||||
r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
|
||||
r = sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
|
||||
if (r < 0)
|
||||
log_link_debug(link, "MAC address not found for new device, continuing without");
|
||||
|
||||
@ -497,7 +497,7 @@ void link_client_handler(Link *link) {
|
||||
return;
|
||||
}
|
||||
|
||||
static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int route_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -511,7 +511,7 @@ static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST)
|
||||
log_link_warning_errno(link, r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
|
||||
|
||||
@ -554,7 +554,7 @@ static int link_enter_set_routes(Link *link) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
int link_route_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -565,14 +565,14 @@ int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -ESRCH)
|
||||
log_link_warning_errno(link, r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int address_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -589,7 +589,7 @@ static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST)
|
||||
log_link_warning_errno(link, r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
|
||||
else if (r >= 0)
|
||||
@ -682,7 +682,7 @@ static int link_enter_set_addresses(Link *link) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
int link_address_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -693,7 +693,7 @@ int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata)
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EADDRNOTAVAIL)
|
||||
log_link_warning_errno(link, r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
|
||||
|
||||
@ -715,13 +715,13 @@ static int link_set_bridge_fdb(Link *const link) {
|
||||
return r;
|
||||
}
|
||||
|
||||
static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int link_set_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
log_link_debug(link, "Set link");
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
log_link_error_errno(link, r, "Could not join netdev: %m");
|
||||
link_enter_failed(link);
|
||||
@ -784,7 +784,7 @@ int link_set_hostname(Link *link, const char *hostname) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -795,7 +795,7 @@ static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0)
|
||||
log_link_warning_errno(link, r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
|
||||
|
||||
@ -803,7 +803,7 @@ static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
}
|
||||
|
||||
int link_set_mtu(Link *link, uint32_t mtu) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -816,11 +816,11 @@ int link_set_mtu(Link *link, uint32_t mtu) {
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
|
||||
r = sd_netlink_message_append_u32(req, IFLA_MTU, mtu);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not append MTU: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -830,7 +830,7 @@ int link_set_mtu(Link *link, uint32_t mtu) {
|
||||
}
|
||||
|
||||
static int link_set_bridge(Link *link) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -847,21 +847,21 @@ static int link_set_bridge(Link *link) {
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not set message family: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
|
||||
r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m");
|
||||
|
||||
if(link->network->cost != 0) {
|
||||
r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
|
||||
r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_close_container(req);
|
||||
r = sd_netlink_message_close_container(req);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -952,7 +952,7 @@ bool link_has_carrier(Link *link) {
|
||||
return false;
|
||||
}
|
||||
|
||||
static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -961,7 +961,7 @@ static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0)
|
||||
/* we warn but don't fail the link, as it may be
|
||||
brought up later */
|
||||
@ -971,7 +971,7 @@ static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
}
|
||||
|
||||
static int link_up(Link *link) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
uint8_t ipv6ll_mode;
|
||||
int r;
|
||||
|
||||
@ -991,48 +991,48 @@ static int link_up(Link *link) {
|
||||
return log_link_error_errno(link, r, "Could not set link flags: %m");
|
||||
|
||||
if (link->network->mac) {
|
||||
r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
|
||||
r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not set MAC address: %m");
|
||||
}
|
||||
|
||||
if (link->network->mtu) {
|
||||
r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
|
||||
r = sd_netlink_message_append_u32(req, IFLA_MTU, link->network->mtu);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not set MTU: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_open_container(req, IFLA_AF_SPEC);
|
||||
r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
|
||||
|
||||
if (socket_ipv6_is_supported()) {
|
||||
/* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
|
||||
r = sd_rtnl_message_open_container(req, AF_INET6);
|
||||
r = sd_netlink_message_open_container(req, AF_INET6);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
|
||||
|
||||
ipv6ll_mode = link_ipv6ll_enabled(link) ? IN6_ADDR_GEN_MODE_EUI64 : IN6_ADDR_GEN_MODE_NONE;
|
||||
r = sd_rtnl_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
|
||||
r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
|
||||
|
||||
if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
|
||||
r = sd_rtnl_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not append IFLA_INET6_TOKEN: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_close_container(req);
|
||||
r = sd_netlink_message_close_container(req);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_close_container(req);
|
||||
r = sd_netlink_message_close_container(req);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -1041,7 +1041,7 @@ static int link_up(Link *link) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int link_down_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
|
||||
@ -1050,7 +1050,7 @@ static int link_down_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata)
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0)
|
||||
log_link_warning_errno(link, r, "%-*s: could not bring down interface: %m", IFNAMSIZ, link->ifname);
|
||||
|
||||
@ -1058,7 +1058,7 @@ static int link_down_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata)
|
||||
}
|
||||
|
||||
static int link_down(Link *link) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -1076,7 +1076,7 @@ static int link_down(Link *link) {
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not set link flags: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, link_down_handler, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, link_down_handler, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -1360,7 +1360,7 @@ static int link_joined(Link *link) {
|
||||
return link_enter_set_addresses(link);
|
||||
}
|
||||
|
||||
static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m,
|
||||
void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
int r;
|
||||
@ -1373,7 +1373,7 @@ static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
|
||||
return 1;
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r < 0 && r != -EEXIST) {
|
||||
log_link_error_errno(link, r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
|
||||
link_enter_failed(link);
|
||||
@ -1578,7 +1578,7 @@ static int link_configure(Link *link) {
|
||||
return link_enter_join_netdev(link);
|
||||
}
|
||||
|
||||
static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
static int link_initialized_and_synced(sd_netlink *rtnl, sd_netlink_message *m,
|
||||
void *userdata) {
|
||||
_cleanup_link_unref_ Link *link = userdata;
|
||||
Network *network;
|
||||
@ -1636,7 +1636,7 @@ static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
|
||||
}
|
||||
|
||||
int link_initialized(Link *link, struct udev_device *device) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -1664,7 +1664,7 @@ int link_initialized(Link *link, struct udev_device *device) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req,
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req,
|
||||
link_initialized_and_synced, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return r;
|
||||
@ -1687,7 +1687,7 @@ static Address* link_get_equal_address(Link *link, Address *needle) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
|
||||
int link_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
|
||||
Manager *m = userdata;
|
||||
Link *link = NULL;
|
||||
uint16_t type;
|
||||
@ -1702,15 +1702,15 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
|
||||
assert(message);
|
||||
assert(m);
|
||||
|
||||
if (sd_rtnl_message_is_error(message)) {
|
||||
r = sd_rtnl_message_get_errno(message);
|
||||
if (sd_netlink_message_is_error(message)) {
|
||||
r = sd_netlink_message_get_errno(message);
|
||||
if (r < 0)
|
||||
log_warning_errno(r, "rtnl: failed to receive address: %m");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_get_type(message, &type);
|
||||
r = sd_netlink_message_get_type(message, &type);
|
||||
if (r < 0) {
|
||||
log_warning_errno(r, "rtnl: could not get message type: %m");
|
||||
return 0;
|
||||
@ -1768,7 +1768,7 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
|
||||
|
||||
switch (address->family) {
|
||||
case AF_INET:
|
||||
r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
|
||||
r = sd_netlink_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
|
||||
if (r < 0) {
|
||||
log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
|
||||
return 0;
|
||||
@ -1777,7 +1777,7 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
|
||||
break;
|
||||
|
||||
case AF_INET6:
|
||||
r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
|
||||
r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
|
||||
if (r < 0) {
|
||||
log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
|
||||
return 0;
|
||||
@ -1794,7 +1794,7 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
|
||||
return 0;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
|
||||
r = sd_netlink_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
|
||||
if (r >= 0) {
|
||||
if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
|
||||
valid_str = "ever";
|
||||
@ -1847,7 +1847,7 @@ int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *use
|
||||
return 1;
|
||||
}
|
||||
|
||||
int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
|
||||
int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
|
||||
Link *link;
|
||||
_cleanup_udev_device_unref_ struct udev_device *device = NULL;
|
||||
char ifindex_str[2 + DECIMAL_STR_MAX(int)];
|
||||
@ -1953,7 +1953,7 @@ int link_carrier_reset(Link *link) {
|
||||
}
|
||||
|
||||
|
||||
int link_update(Link *link, sd_rtnl_message *m) {
|
||||
int link_update(Link *link, sd_netlink_message *m) {
|
||||
struct ether_addr mac;
|
||||
const char *ifname;
|
||||
uint32_t mtu;
|
||||
@ -1974,7 +1974,7 @@ int link_update(Link *link, sd_rtnl_message *m) {
|
||||
return r;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
|
||||
r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
|
||||
if (r >= 0 && !streq(ifname, link->ifname)) {
|
||||
log_link_info(link, "Renamed to %s", ifname);
|
||||
|
||||
@ -1990,7 +1990,7 @@ int link_update(Link *link, sd_rtnl_message *m) {
|
||||
return r;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
|
||||
r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
|
||||
if (r >= 0 && mtu > 0) {
|
||||
link->mtu = mtu;
|
||||
if (!link->original_mtu) {
|
||||
@ -2010,7 +2010,7 @@ int link_update(Link *link, sd_rtnl_message *m) {
|
||||
|
||||
/* The kernel may broadcast NEWLINK messages without the MAC address
|
||||
set, simply ignore them. */
|
||||
r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
|
||||
r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
|
||||
if (r >= 0) {
|
||||
if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
|
||||
ETH_ALEN)) {
|
||||
|
@ -94,19 +94,19 @@ struct Link {
|
||||
Link *link_unref(Link *link);
|
||||
Link *link_ref(Link *link);
|
||||
int link_get(Manager *m, int ifindex, Link **ret);
|
||||
int link_add(Manager *manager, sd_rtnl_message *message, Link **ret);
|
||||
int link_add(Manager *manager, sd_netlink_message *message, Link **ret);
|
||||
void link_drop(Link *link);
|
||||
|
||||
int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata);
|
||||
int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata);
|
||||
int link_address_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata);
|
||||
int link_route_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata);
|
||||
|
||||
void link_enter_failed(Link *link);
|
||||
int link_initialized(Link *link, struct udev_device *device);
|
||||
|
||||
void link_client_handler(Link *link);
|
||||
|
||||
int link_update(Link *link, sd_rtnl_message *message);
|
||||
int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata);
|
||||
int link_update(Link *link, sd_netlink_message *message);
|
||||
int link_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, void *userdata);
|
||||
|
||||
int link_save(Link *link);
|
||||
|
||||
|
@ -29,12 +29,12 @@
|
||||
#include "networkd-link.h"
|
||||
#include "libudev-private.h"
|
||||
#include "udev-util.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "bus-util.h"
|
||||
#include "def.h"
|
||||
#include "virt.h"
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "sd-daemon.h"
|
||||
|
||||
/* use 8 MB for receive socket kernel queue. */
|
||||
@ -274,7 +274,7 @@ static int manager_connect_udev(Manager *m) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
|
||||
static int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
|
||||
Manager *m = userdata;
|
||||
Link *link = NULL;
|
||||
NetDev *netdev = NULL;
|
||||
@ -286,15 +286,15 @@ static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, vo
|
||||
assert(message);
|
||||
assert(m);
|
||||
|
||||
if (sd_rtnl_message_is_error(message)) {
|
||||
r = sd_rtnl_message_get_errno(message);
|
||||
if (sd_netlink_message_is_error(message)) {
|
||||
r = sd_netlink_message_get_errno(message);
|
||||
if (r < 0)
|
||||
log_warning_errno(r, "rtnl: could not receive link: %m");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_get_type(message, &type);
|
||||
r = sd_netlink_message_get_type(message, &type);
|
||||
if (r < 0) {
|
||||
log_warning_errno(r, "rtnl: could not get message type: %m");
|
||||
return 0;
|
||||
@ -313,7 +313,7 @@ static int manager_rtnl_process_link(sd_rtnl *rtnl, sd_rtnl_message *message, vo
|
||||
} else
|
||||
link_get(m, ifindex, &link);
|
||||
|
||||
r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &name);
|
||||
r = sd_netlink_message_read_string(message, IFLA_IFNAME, &name);
|
||||
if (r < 0) {
|
||||
log_warning_errno(r, "rtnl: received link message without ifname: %m");
|
||||
return 0;
|
||||
@ -385,33 +385,33 @@ static int manager_connect_rtnl(Manager *m) {
|
||||
|
||||
fd = systemd_netlink_fd();
|
||||
if (fd < 0)
|
||||
r = sd_rtnl_open(&m->rtnl);
|
||||
r = sd_netlink_open(&m->rtnl);
|
||||
else
|
||||
r = sd_rtnl_open_fd(&m->rtnl, fd);
|
||||
r = sd_netlink_open_fd(&m->rtnl, fd);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
|
||||
r = sd_netlink_inc_rcvbuf(m->rtnl, RCVBUF_SIZE);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
|
||||
r = sd_netlink_attach_event(m->rtnl, m->event, 0);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, &manager_rtnl_process_link, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, &manager_rtnl_process_link, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_NEWADDR, &link_rtnl_process_address, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_DELADDR, &link_rtnl_process_address, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -498,7 +498,7 @@ void manager_free(Manager *m) {
|
||||
while ((pool = m->address_pools))
|
||||
address_pool_free(pool);
|
||||
|
||||
sd_rtnl_unref(m->rtnl);
|
||||
sd_netlink_unref(m->rtnl);
|
||||
|
||||
free(m);
|
||||
}
|
||||
@ -570,8 +570,8 @@ bool manager_should_reload(Manager *m) {
|
||||
}
|
||||
|
||||
int manager_rtnl_enumerate_links(Manager *m) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
sd_rtnl_message *link;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
sd_netlink_message *link;
|
||||
int r;
|
||||
|
||||
assert(m);
|
||||
@ -581,15 +581,15 @@ int manager_rtnl_enumerate_links(Manager *m) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(m->rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(m->rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (link = reply; link; link = sd_rtnl_message_next(link)) {
|
||||
for (link = reply; link; link = sd_netlink_message_next(link)) {
|
||||
int k;
|
||||
|
||||
m->enumerating = true;
|
||||
@ -605,8 +605,8 @@ int manager_rtnl_enumerate_links(Manager *m) {
|
||||
}
|
||||
|
||||
int manager_rtnl_enumerate_addresses(Manager *m) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
sd_rtnl_message *addr;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
sd_netlink_message *addr;
|
||||
int r;
|
||||
|
||||
assert(m);
|
||||
@ -616,15 +616,15 @@ int manager_rtnl_enumerate_addresses(Manager *m) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(m->rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(m->rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (addr = reply; addr; addr = sd_rtnl_message_next(addr)) {
|
||||
for (addr = reply; addr; addr = sd_netlink_message_next(addr)) {
|
||||
int k;
|
||||
|
||||
m->enumerating = true;
|
||||
|
@ -24,8 +24,8 @@
|
||||
#include <linux/if_bonding.h>
|
||||
|
||||
#include "conf-parser.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "rtnl-types.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "netlink-types.h"
|
||||
#include "networkd-netdev-bond.h"
|
||||
#include "missing.h"
|
||||
|
||||
@ -178,7 +178,7 @@ static uint8_t bond_xmit_hash_policy_to_kernel(BondXmitHashPolicy policy) {
|
||||
}
|
||||
}
|
||||
|
||||
static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Bond *b = BOND(netdev);
|
||||
ArpIpTarget *target = NULL;
|
||||
int r, i = 0;
|
||||
@ -189,14 +189,14 @@ static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
assert(m);
|
||||
|
||||
if (b->mode != _NETDEV_BOND_MODE_INVALID) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_MODE,
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_MODE,
|
||||
bond_mode_to_kernel(b->mode));
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MODE attribute: %m");
|
||||
}
|
||||
|
||||
if (b->xmit_hash_policy != _NETDEV_BOND_XMIT_HASH_POLICY_INVALID) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY,
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_XMIT_HASH_POLICY,
|
||||
bond_xmit_hash_policy_to_kernel(b->xmit_hash_policy));
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_XMIT_HASH_POLICY attribute: %m");
|
||||
@ -204,38 +204,38 @@ static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
|
||||
if (b->lacp_rate != _NETDEV_BOND_LACP_RATE_INVALID &&
|
||||
b->mode == NETDEV_BOND_MODE_802_3AD) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate );
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_LACP_RATE, b->lacp_rate );
|
||||
if (r < 0) {
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_LACP_RATE attribute: %m");
|
||||
}
|
||||
}
|
||||
|
||||
if (b->miimon != 0) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_MIIMON, b->miimon / USEC_PER_MSEC);
|
||||
if (r < 0)
|
||||
log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_BOND_MIIMON attribute: %m");
|
||||
}
|
||||
|
||||
if (b->downdelay != 0) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_DOWNDELAY, b->downdelay / USEC_PER_MSEC);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_DOWNDELAY attribute: %m");
|
||||
}
|
||||
|
||||
if (b->updelay != 0) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_UPDELAY, b->updelay / USEC_PER_MSEC);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_UPDELAY attribute: %m");
|
||||
}
|
||||
|
||||
if (b->arp_interval != 0) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_INTERVAL, b->arp_interval / USEC_PER_MSEC);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_INTERVAL attribute: %m");
|
||||
|
||||
if ((b->lp_interval >= LEARNING_PACKETS_INTERVAL_MIN_SEC) &&
|
||||
(b->lp_interval <= LEARNING_PACKETS_INTERVAL_MAX_SEC)) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_LP_INTERVAL, b->lp_interval / USEC_PER_SEC);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_LP_INTERVAL attribute: %m");
|
||||
}
|
||||
@ -243,79 +243,79 @@ static int netdev_bond_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
|
||||
if (b->ad_select != _NETDEV_BOND_AD_SELECT_INVALID &&
|
||||
b->mode == NETDEV_BOND_MODE_802_3AD) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_AD_SELECT, b->ad_select);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_AD_SELECT attribute: %m");
|
||||
}
|
||||
|
||||
if (b->fail_over_mac != _NETDEV_BOND_FAIL_OVER_MAC_INVALID &&
|
||||
b->mode == NETDEV_BOND_MODE_ACTIVE_BACKUP) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_FAIL_OVER_MAC, b->fail_over_mac);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_FAIL_OVER_MAC attribute: %m");
|
||||
}
|
||||
|
||||
if (b->arp_validate != _NETDEV_BOND_ARP_VALIDATE_INVALID) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_VALIDATE, b->arp_validate);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_VALIDATE attribute: %m");
|
||||
}
|
||||
|
||||
if (b->arp_all_targets != _NETDEV_BOND_ARP_ALL_TARGETS_INVALID) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->arp_all_targets);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_VALIDATE attribute: %m");
|
||||
}
|
||||
|
||||
if (b->primary_reselect != _NETDEV_BOND_PRIMARY_RESELECT_INVALID) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->primary_reselect);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_ARP_ALL_TARGETS, b->primary_reselect);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
|
||||
}
|
||||
|
||||
if (b->resend_igmp <= RESEND_IGMP_MAX) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_RESEND_IGMP, b->resend_igmp);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_RESEND_IGMP attribute: %m");
|
||||
}
|
||||
|
||||
if (b->packets_per_slave <= PACKETS_PER_SLAVE_MAX &&
|
||||
b->mode == NETDEV_BOND_MODE_BALANCE_RR) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_PACKETS_PER_SLAVE, b->packets_per_slave);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_PACKETS_PER_SLAVE attribute: %m");
|
||||
}
|
||||
|
||||
if (b->num_grat_arp <= GRATUITOUS_ARP_MAX) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_NUM_PEER_NOTIF, b->num_grat_arp);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_NUM_PEER_NOTIF attribute: %m");
|
||||
}
|
||||
|
||||
if (b->min_links != 0) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_BOND_MIN_LINKS, b->min_links);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_MIN_LINKS attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_BOND_ALL_SLAVES_ACTIVE, b->all_slaves_active);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ALL_SLAVES_ACTIVE attribute: %m");
|
||||
|
||||
if (b->arp_interval > 0) {
|
||||
if (b->n_arp_ip_targets > 0) {
|
||||
|
||||
r = sd_rtnl_message_open_container(m, IFLA_BOND_ARP_IP_TARGET);
|
||||
r = sd_netlink_message_open_container(m, IFLA_BOND_ARP_IP_TARGET);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not open contaniner IFLA_BOND_ARP_IP_TARGET : %m");
|
||||
|
||||
LIST_FOREACH(arp_ip_target, target, b->arp_ip_targets) {
|
||||
r = sd_rtnl_message_append_u32(m, i++, target->ip.in.s_addr);
|
||||
r = sd_netlink_message_append_u32(m, i++, target->ip.in.s_addr);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_BOND_ARP_ALL_TARGETS attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not close contaniner IFLA_BOND_ARP_IP_TARGET : %m");
|
||||
}
|
||||
|
@ -32,7 +32,7 @@ static const char* const ipvlan_mode_table[_NETDEV_IPVLAN_MODE_MAX] = {
|
||||
DEFINE_STRING_TABLE_LOOKUP(ipvlan_mode, IPVlanMode);
|
||||
DEFINE_CONFIG_PARSE_ENUM(config_parse_ipvlan_mode, ipvlan_mode, IPVlanMode, "Failed to parse ipvlan mode");
|
||||
|
||||
static int netdev_ipvlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *req) {
|
||||
static int netdev_ipvlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
|
||||
IPVlan *m = IPVLAN(netdev);
|
||||
int r;
|
||||
|
||||
@ -42,7 +42,7 @@ static int netdev_ipvlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl
|
||||
assert(netdev->ifname);
|
||||
|
||||
if (m->mode != _NETDEV_IPVLAN_MODE_INVALID) {
|
||||
r = sd_rtnl_message_append_u16(req, IFLA_IPVLAN_MODE, m->mode);
|
||||
r = sd_netlink_message_append_u16(req, IFLA_IPVLAN_MODE, m->mode);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPVLAN_MODE attribute: %m");
|
||||
}
|
||||
|
@ -34,7 +34,7 @@ static const char* const macvlan_mode_table[_NETDEV_MACVLAN_MODE_MAX] = {
|
||||
DEFINE_STRING_TABLE_LOOKUP(macvlan_mode, MacVlanMode);
|
||||
DEFINE_CONFIG_PARSE_ENUM(config_parse_macvlan_mode, macvlan_mode, MacVlanMode, "Failed to parse macvlan mode");
|
||||
|
||||
static int netdev_macvlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *req) {
|
||||
static int netdev_macvlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
|
||||
MacVlan *m = MACVLAN(netdev);
|
||||
int r;
|
||||
|
||||
@ -44,7 +44,7 @@ static int netdev_macvlan_fill_message_create(NetDev *netdev, Link *link, sd_rtn
|
||||
assert(netdev->ifname);
|
||||
|
||||
if (m->mode != _NETDEV_MACVLAN_MODE_INVALID) {
|
||||
r = sd_rtnl_message_append_u32(req, IFLA_MACVLAN_MODE, m->mode);
|
||||
r = sd_netlink_message_append_u32(req, IFLA_MACVLAN_MODE, m->mode);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MACVLAN_MODE attribute: %m");
|
||||
}
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include <linux/if_tunnel.h>
|
||||
#include <linux/ip6_tunnel.h>
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "networkd-netdev-tunnel.h"
|
||||
#include "networkd-link.h"
|
||||
#include "util.h"
|
||||
@ -43,7 +43,7 @@ static const char* const ip6tnl_mode_table[_NETDEV_IP6_TNL_MODE_MAX] = {
|
||||
DEFINE_STRING_TABLE_LOOKUP(ip6tnl_mode, Ip6TnlMode);
|
||||
DEFINE_CONFIG_PARSE_ENUM(config_parse_ip6tnl_mode, ip6tnl_mode, Ip6TnlMode, "Failed to parse ip6 tunnel Mode");
|
||||
|
||||
static int netdev_ipip_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_ipip_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t = IPIP(netdev);
|
||||
int r;
|
||||
|
||||
@ -53,30 +53,30 @@ static int netdev_ipip_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
assert(t);
|
||||
assert(t->family == AF_INET);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int netdev_sit_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_sit_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t = SIT(netdev);
|
||||
int r;
|
||||
|
||||
@ -86,30 +86,30 @@ static int netdev_sit_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_me
|
||||
assert(t);
|
||||
assert(t->family == AF_INET);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_LOCAL, &t->local.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PMTUDISC, t->pmtudisc);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_PMTUDISC attribute: %m");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int netdev_gre_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t;
|
||||
int r;
|
||||
|
||||
@ -125,34 +125,34 @@ static int netdev_gre_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_me
|
||||
assert(link);
|
||||
assert(m);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_GRE_LOCAL, &t->local.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_GRE_LOCAL, &t->local.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_GRE_REMOTE, &t->remote.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_GRE_REMOTE, &t->remote.in);
|
||||
if (r < 0)
|
||||
log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_GRE_TOS, t->tos);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_GRE_TOS, t->tos);
|
||||
if (r < 0)
|
||||
log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TOS attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_GRE_PMTUDISC, t->pmtudisc);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_GRE_PMTUDISC, t->pmtudisc);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_PMTUDISC attribute: %m");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t;
|
||||
int r;
|
||||
|
||||
@ -168,26 +168,26 @@ static int netdev_ip6gre_fill_message_create(NetDev *netdev, Link *link, sd_rtnl
|
||||
assert(link);
|
||||
assert(m);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_GRE_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in6_addr(m, IFLA_GRE_LOCAL, &t->local.in6);
|
||||
r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_LOCAL, &t->local.in6);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in6_addr(m, IFLA_GRE_REMOTE, &t->remote.in6);
|
||||
r = sd_netlink_message_append_in6_addr(m, IFLA_GRE_REMOTE, &t->remote.in6);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_REMOTE attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_GRE_TTL, t->ttl);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_GRE_TTL attribute: %m");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t = VTI(netdev);
|
||||
int r;
|
||||
|
||||
@ -197,22 +197,22 @@ static int netdev_vti_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_me
|
||||
assert(t);
|
||||
assert(t->family == AF_INET);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_VTI_LOCAL, &t->local.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_VTI_LOCAL, &t->local.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_VTI_REMOTE, &t->remote.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_VTI_REMOTE, &t->remote.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int netdev_vti6_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_vti6_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t = VTI6(netdev);
|
||||
int r;
|
||||
|
||||
@ -222,22 +222,22 @@ static int netdev_vti6_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
assert(t);
|
||||
assert(t->family == AF_INET6);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_VTI_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in6_addr(m, IFLA_VTI_LOCAL, &t->local.in6);
|
||||
r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_LOCAL, &t->local.in6);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in6_addr(m, IFLA_VTI_REMOTE, &t->remote.in6);
|
||||
r = sd_netlink_message_append_in6_addr(m, IFLA_VTI_REMOTE, &t->remote.in6);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Tunnel *t = IP6TNL(netdev);
|
||||
uint8_t proto;
|
||||
int r;
|
||||
@ -248,19 +248,19 @@ static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_rtnl
|
||||
assert(t);
|
||||
assert(t->family == AF_INET6);
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_IPTUN_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LINK attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in6_addr(m, IFLA_IPTUN_LOCAL, &t->local.in6);
|
||||
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_LOCAL, &t->local.in6);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_LOCAL attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_in6_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in6);
|
||||
r = sd_netlink_message_append_in6_addr(m, IFLA_IPTUN_REMOTE, &t->remote.in6);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_REMOTE attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_TTL, t->ttl);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_TTL attribute: %m");
|
||||
|
||||
@ -277,7 +277,7 @@ static int netdev_ip6tnl_fill_message_create(NetDev *netdev, Link *link, sd_rtnl
|
||||
break;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_IPTUN_PROTO, proto);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_IPTUN_PROTO, proto);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IPTUN_MODE attribute: %m");
|
||||
|
||||
|
@ -22,10 +22,10 @@
|
||||
#include <net/if.h>
|
||||
#include <linux/veth.h>
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "networkd-netdev-veth.h"
|
||||
|
||||
static int netdev_veth_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_veth_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
Veth *v = VETH(netdev);
|
||||
int r;
|
||||
|
||||
@ -34,23 +34,23 @@ static int netdev_veth_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
assert(v);
|
||||
assert(m);
|
||||
|
||||
r = sd_rtnl_message_open_container(m, VETH_INFO_PEER);
|
||||
r = sd_netlink_message_open_container(m, VETH_INFO_PEER);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append VETH_INFO_PEER attribute: %m");
|
||||
|
||||
if (v->ifname_peer) {
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, v->ifname_peer);
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, v->ifname_peer);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface name: %m");
|
||||
}
|
||||
|
||||
if (v->mac_peer) {
|
||||
r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, v->mac_peer);
|
||||
r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, v->mac_peer);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_ADDRESS attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
|
||||
|
||||
|
@ -23,7 +23,7 @@
|
||||
|
||||
#include "networkd-netdev-vlan.h"
|
||||
|
||||
static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *req) {
|
||||
static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *req) {
|
||||
VLan *v = VLAN(netdev);
|
||||
int r;
|
||||
|
||||
@ -33,7 +33,7 @@ static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_m
|
||||
assert(req);
|
||||
|
||||
if (v->id <= VLANID_MAX) {
|
||||
r = sd_rtnl_message_append_u16(req, IFLA_VLAN_ID, v->id);
|
||||
r = sd_netlink_message_append_u16(req, IFLA_VLAN_ID, v->id);
|
||||
if (r < 0) {
|
||||
log_netdev_error(netdev,
|
||||
"Could not append IFLA_VLAN_ID attribute: %s",
|
||||
|
@ -21,13 +21,13 @@
|
||||
|
||||
#include <net/if.h>
|
||||
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "networkd-netdev-vxlan.h"
|
||||
#include "networkd-link.h"
|
||||
#include "conf-parser.h"
|
||||
#include "missing.h"
|
||||
|
||||
static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *m) {
|
||||
static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
|
||||
VxLan *v = VXLAN(netdev);
|
||||
int r;
|
||||
|
||||
@ -38,66 +38,66 @@ static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_
|
||||
|
||||
|
||||
if (v->id <= VXLAN_VID_MAX) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_VXLAN_ID, v->id);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_ID, v->id);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_ID attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_in_addr(m, IFLA_VXLAN_GROUP, &v->group.in);
|
||||
r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_GROUP, &v->group.in);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_GROUP attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_VXLAN_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LINK attribute: %m");
|
||||
|
||||
if(v->ttl) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_TTL, v->ttl);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TTL, v->ttl);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_TTL attribute: %m");
|
||||
}
|
||||
|
||||
if(v->tos) {
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_TOS, v->tos);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TOS, v->tos);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_TOS attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_LEARNING, v->learning);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_LEARNING, v->learning);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_LEARNING attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_RSC, v->route_short_circuit);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_RSC, v->route_short_circuit);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_RSC attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_PROXY, v->arp_proxy);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_PROXY, v->arp_proxy);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_PROXY attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_L2MISS, v->l2miss);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L2MISS, v->l2miss);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_L2MISS attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_L3MISS, v->l3miss);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L3MISS, v->l3miss);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_L3MISS attribute: %m");
|
||||
|
||||
if(v->fdb_ageing) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_VXLAN_AGEING, v->fdb_ageing / USEC_PER_SEC);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_VXLAN_AGEING, v->fdb_ageing / USEC_PER_SEC);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_AGEING attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_UDP_CSUM, v->udpcsum);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_CSUM, v->udpcsum);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_UDP_CSUM attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, v->udp6zerocsumtx);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, v->udp6zerocsumtx);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_UDP_ZERO_CSUM6_TX attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, v->udp6zerocsumrx);
|
||||
r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, v->udp6zerocsumrx);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_VXLAN_UDP_ZERO_CSUM6_RX attribute: %m");
|
||||
|
||||
|
@ -77,7 +77,7 @@ DEFINE_STRING_TABLE_LOOKUP(netdev_kind, NetDevKind);
|
||||
DEFINE_CONFIG_PARSE_ENUM(config_parse_netdev_kind, netdev_kind, NetDevKind, "Failed to parse netdev kind");
|
||||
|
||||
static void netdev_cancel_callbacks(NetDev *netdev) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
netdev_join_callback *callback;
|
||||
|
||||
if (!netdev)
|
||||
@ -180,8 +180,8 @@ static int netdev_enter_failed(NetDev *netdev) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int netdev_enslave_ready(NetDev *netdev, Link* link, sd_rtnl_message_handler_t callback) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
static int netdev_enslave_ready(NetDev *netdev, Link* link, sd_netlink_message_handler_t callback) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(netdev);
|
||||
@ -196,11 +196,11 @@ static int netdev_enslave_ready(NetDev *netdev, Link* link, sd_rtnl_message_hand
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not allocate RTM_SETLINK message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, IFLA_MASTER, netdev->ifindex);
|
||||
r = sd_netlink_message_append_u32(req, IFLA_MASTER, netdev->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MASTER attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(netdev->manager->rtnl, req, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(netdev->manager->rtnl, req, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_netdev_error(netdev, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -241,13 +241,13 @@ static int netdev_enter_ready(NetDev *netdev) {
|
||||
}
|
||||
|
||||
/* callback for netdev's created without a backing Link */
|
||||
static int netdev_create_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int netdev_create_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
_cleanup_netdev_unref_ NetDev *netdev = userdata;
|
||||
int r;
|
||||
|
||||
assert(netdev->state != _NETDEV_STATE_INVALID);
|
||||
|
||||
r = sd_rtnl_message_get_errno(m);
|
||||
r = sd_netlink_message_get_errno(m);
|
||||
if (r == -EEXIST)
|
||||
log_netdev_info(netdev, "netdev exists, using existing without changing its parameters");
|
||||
else if (r < 0) {
|
||||
@ -262,7 +262,7 @@ static int netdev_create_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userda
|
||||
return 1;
|
||||
}
|
||||
|
||||
int netdev_enslave(NetDev *netdev, Link *link, sd_rtnl_message_handler_t callback) {
|
||||
int netdev_enslave(NetDev *netdev, Link *link, sd_netlink_message_handler_t callback) {
|
||||
int r;
|
||||
|
||||
assert(netdev);
|
||||
@ -292,7 +292,7 @@ int netdev_enslave(NetDev *netdev, Link *link, sd_rtnl_message_handler_t callbac
|
||||
return 0;
|
||||
}
|
||||
|
||||
int netdev_set_ifindex(NetDev *netdev, sd_rtnl_message *message) {
|
||||
int netdev_set_ifindex(NetDev *netdev, sd_netlink_message *message) {
|
||||
uint16_t type;
|
||||
const char *kind;
|
||||
const char *received_kind;
|
||||
@ -302,7 +302,7 @@ int netdev_set_ifindex(NetDev *netdev, sd_rtnl_message *message) {
|
||||
assert(netdev);
|
||||
assert(message);
|
||||
|
||||
r = sd_rtnl_message_get_type(message, &type);
|
||||
r = sd_netlink_message_get_type(message, &type);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not get rtnl message type: %m");
|
||||
|
||||
@ -333,7 +333,7 @@ int netdev_set_ifindex(NetDev *netdev, sd_rtnl_message *message) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &received_name);
|
||||
r = sd_netlink_message_read_string(message, IFLA_IFNAME, &received_name);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not get IFNAME: %m");
|
||||
|
||||
@ -343,15 +343,15 @@ int netdev_set_ifindex(NetDev *netdev, sd_rtnl_message *message) {
|
||||
return r;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_enter_container(message, IFLA_LINKINFO);
|
||||
r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not get LINKINFO: %m");
|
||||
|
||||
r = sd_rtnl_message_read_string(message, IFLA_INFO_KIND, &received_kind);
|
||||
r = sd_netlink_message_read_string(message, IFLA_INFO_KIND, &received_kind);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not get KIND: %m");
|
||||
|
||||
r = sd_rtnl_message_exit_container(message);
|
||||
r = sd_netlink_message_exit_container(message);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not exit container: %m");
|
||||
|
||||
@ -431,7 +431,7 @@ int netdev_get_mac(const char *ifname, struct ether_addr **ret) {
|
||||
}
|
||||
|
||||
static int netdev_create(NetDev *netdev, Link *link,
|
||||
sd_rtnl_message_handler_t callback) {
|
||||
sd_netlink_message_handler_t callback) {
|
||||
int r;
|
||||
|
||||
assert(netdev);
|
||||
@ -447,39 +447,39 @@ static int netdev_create(NetDev *netdev, Link *link,
|
||||
|
||||
log_netdev_debug(netdev, "Created");
|
||||
} else {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
|
||||
r = sd_rtnl_message_new_link(netdev->manager->rtnl, &m, RTM_NEWLINK, 0);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not allocate RTM_NEWLINK message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, netdev->ifname);
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, netdev->ifname);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_IFNAME, attribute: %m");
|
||||
|
||||
if (netdev->mac) {
|
||||
r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
|
||||
r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, netdev->mac);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_ADDRESS attribute: %m");
|
||||
}
|
||||
|
||||
if (netdev->mtu) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_MTU, netdev->mtu);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_MTU, netdev->mtu);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_MTU attribute: %m");
|
||||
}
|
||||
|
||||
if (link) {
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_LINK, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_LINK, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINK attribute: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
|
||||
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
|
||||
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
|
||||
|
||||
@ -489,22 +489,22 @@ static int netdev_create(NetDev *netdev, Link *link,
|
||||
return r;
|
||||
}
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
|
||||
|
||||
if (link) {
|
||||
r = sd_rtnl_call_async(netdev->manager->rtnl, m, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(netdev->manager->rtnl, m, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
link_ref(link);
|
||||
} else {
|
||||
r = sd_rtnl_call_async(netdev->manager->rtnl, m, netdev_create_handler, netdev, 0, NULL);
|
||||
r = sd_netlink_call_async(netdev->manager->rtnl, m, netdev_create_handler, netdev, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -520,7 +520,7 @@ static int netdev_create(NetDev *netdev, Link *link,
|
||||
}
|
||||
|
||||
/* the callback must be called, possibly after a timeout, as otherwise the Link will hang */
|
||||
int netdev_join(NetDev *netdev, Link *link, sd_rtnl_message_handler_t callback) {
|
||||
int netdev_join(NetDev *netdev, Link *link, sd_netlink_message_handler_t callback) {
|
||||
int r;
|
||||
|
||||
assert(netdev);
|
||||
|
@ -29,7 +29,7 @@ typedef struct NetDevVTable NetDevVTable;
|
||||
typedef struct netdev_join_callback netdev_join_callback;
|
||||
|
||||
struct netdev_join_callback {
|
||||
sd_rtnl_message_handler_t callback;
|
||||
sd_netlink_message_handler_t callback;
|
||||
Link *link;
|
||||
|
||||
LIST_FIELDS(netdev_join_callback, callbacks);
|
||||
@ -129,7 +129,7 @@ struct NetDevVTable {
|
||||
void (*done)(NetDev *n);
|
||||
|
||||
/* fill in message to create netdev */
|
||||
int (*fill_message_create)(NetDev *netdev, Link *link, sd_rtnl_message *message);
|
||||
int (*fill_message_create)(NetDev *netdev, Link *link, sd_netlink_message *message);
|
||||
|
||||
/* specifies if netdev is independent, or a master device or a stacked device */
|
||||
NetDevCreateType create_type;
|
||||
@ -187,10 +187,10 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(NetDev*, netdev_unref);
|
||||
#define _cleanup_netdev_unref_ _cleanup_(netdev_unrefp)
|
||||
|
||||
int netdev_get(Manager *manager, const char *name, NetDev **ret);
|
||||
int netdev_set_ifindex(NetDev *netdev, sd_rtnl_message *newlink);
|
||||
int netdev_enslave(NetDev *netdev, Link *link, sd_rtnl_message_handler_t callback);
|
||||
int netdev_set_ifindex(NetDev *netdev, sd_netlink_message *newlink);
|
||||
int netdev_enslave(NetDev *netdev, Link *link, sd_netlink_message_handler_t callback);
|
||||
int netdev_get_mac(const char *ifname, struct ether_addr **ret);
|
||||
int netdev_join(NetDev *netdev, Link *link, sd_rtnl_message_handler_t cb);
|
||||
int netdev_join(NetDev *netdev, Link *link, sd_netlink_message_handler_t cb);
|
||||
|
||||
const char *netdev_kind_to_string(NetDevKind d) _const_;
|
||||
NetDevKind netdev_kind_from_string(const char *d) _pure_;
|
||||
|
@ -97,8 +97,8 @@ void route_free(Route *route) {
|
||||
}
|
||||
|
||||
int route_drop(Route *route, Link *link,
|
||||
sd_rtnl_message_handler_t callback) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
sd_netlink_message_handler_t callback) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -115,18 +115,18 @@ int route_drop(Route *route, Link *link,
|
||||
|
||||
if (!in_addr_is_null(route->family, &route->in_addr)) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
|
||||
}
|
||||
|
||||
if (route->dst_prefixlen) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_DST attribute: %m");
|
||||
|
||||
@ -137,9 +137,9 @@ int route_drop(Route *route, Link *link,
|
||||
|
||||
if (route->src_prefixlen) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_DST attribute: %m");
|
||||
|
||||
@ -150,9 +150,9 @@ int route_drop(Route *route, Link *link,
|
||||
|
||||
if (!in_addr_is_null(route->family, &route->prefsrc_addr)) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_PREFSRC attribute: %m");
|
||||
}
|
||||
@ -161,15 +161,15 @@ int route_drop(Route *route, Link *link,
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not set scope: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, RTA_PRIORITY, route->metrics);
|
||||
r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->metrics);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_PRIORITY attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, RTA_OIF, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_OIF attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not send rtnetlink message: %m");
|
||||
|
||||
@ -179,8 +179,8 @@ int route_drop(Route *route, Link *link,
|
||||
}
|
||||
|
||||
int route_configure(Route *route, Link *link,
|
||||
sd_rtnl_message_handler_t callback) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
|
||||
sd_netlink_message_handler_t callback) {
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
|
||||
int r;
|
||||
|
||||
assert(link);
|
||||
@ -197,18 +197,18 @@ int route_configure(Route *route, Link *link,
|
||||
|
||||
if (!in_addr_is_null(route->family, &route->in_addr)) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_GATEWAY, &route->in_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_GATEWAY, &route->in_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_GATEWAY attribute: %m");
|
||||
}
|
||||
|
||||
if (route->dst_prefixlen) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_DST, &route->dst_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_DST, &route->dst_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_DST attribute: %m");
|
||||
|
||||
@ -219,9 +219,9 @@ int route_configure(Route *route, Link *link,
|
||||
|
||||
if (route->src_prefixlen) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_SRC, &route->src_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_SRC, &route->src_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_SRC attribute: %m");
|
||||
|
||||
@ -232,9 +232,9 @@ int route_configure(Route *route, Link *link,
|
||||
|
||||
if (!in_addr_is_null(route->family, &route->prefsrc_addr)) {
|
||||
if (route->family == AF_INET)
|
||||
r = sd_rtnl_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
|
||||
r = sd_netlink_message_append_in_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in);
|
||||
else if (route->family == AF_INET6)
|
||||
r = sd_rtnl_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
|
||||
r = sd_netlink_message_append_in6_addr(req, RTA_PREFSRC, &route->prefsrc_addr.in6);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_PREFSRC attribute: %m");
|
||||
}
|
||||
@ -243,15 +243,15 @@ int route_configure(Route *route, Link *link,
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not set scope: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, RTA_PRIORITY, route->metrics);
|
||||
r = sd_netlink_message_append_u32(req, RTA_PRIORITY, route->metrics);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_PRIORITY attribute: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(req, RTA_OIF, link->ifindex);
|
||||
r = sd_netlink_message_append_u32(req, RTA_OIF, link->ifindex);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not append RTA_OIF attribute: %m");
|
||||
|
||||
r = sd_rtnl_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
r = sd_netlink_call_async(link->manager->rtnl, req, callback, link, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Could not send rtnetlink message: %m");
|
||||
|
||||
|
@ -82,7 +82,7 @@ Link *link_free(Link *l) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int link_update_rtnl(Link *l, sd_rtnl_message *m) {
|
||||
int link_update_rtnl(Link *l, sd_netlink_message *m) {
|
||||
const char *ifname;
|
||||
int r;
|
||||
|
||||
@ -94,7 +94,7 @@ int link_update_rtnl(Link *l, sd_rtnl_message *m) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
|
||||
r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
|
@ -39,7 +39,7 @@ struct Link {
|
||||
|
||||
int link_new(Manager *m, Link **ret, int ifindex, const char *ifname);
|
||||
Link *link_free(Link *l);
|
||||
int link_update_rtnl(Link *l, sd_rtnl_message *m);
|
||||
int link_update_rtnl(Link *l, sd_netlink_message *m);
|
||||
int link_update_monitor(Link *l);
|
||||
bool link_relevant(Link *l);
|
||||
|
||||
|
@ -23,7 +23,7 @@
|
||||
#include <linux/if.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
|
||||
#include "network-internal.h"
|
||||
#include "networkd-wait-online-link.h"
|
||||
@ -93,7 +93,7 @@ bool manager_all_configured(Manager *m) {
|
||||
return one_ready;
|
||||
}
|
||||
|
||||
static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
|
||||
static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
|
||||
Manager *m = userdata;
|
||||
uint16_t type;
|
||||
Link *l;
|
||||
@ -104,7 +104,7 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda
|
||||
assert(m);
|
||||
assert(mm);
|
||||
|
||||
r = sd_rtnl_message_get_type(mm, &type);
|
||||
r = sd_netlink_message_get_type(mm, &type);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
@ -112,7 +112,7 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
r = sd_rtnl_message_read_string(mm, IFLA_IFNAME, &ifname);
|
||||
r = sd_netlink_message_read_string(mm, IFLA_IFNAME, &ifname);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
@ -155,7 +155,7 @@ fail:
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int on_rtnl_event(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
|
||||
static int on_rtnl_event(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
|
||||
Manager *m = userdata;
|
||||
int r;
|
||||
|
||||
@ -170,26 +170,26 @@ static int on_rtnl_event(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
|
||||
}
|
||||
|
||||
static int manager_rtnl_listen(Manager *m) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
sd_rtnl_message *i;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
sd_netlink_message *i;
|
||||
int r;
|
||||
|
||||
assert(m);
|
||||
|
||||
/* First, subscribe to interfaces coming and going */
|
||||
r = sd_rtnl_open(&m->rtnl);
|
||||
r = sd_netlink_open(&m->rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
|
||||
r = sd_netlink_attach_event(m->rtnl, m->event, 0);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, on_rtnl_event, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, on_rtnl_event, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, on_rtnl_event, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, on_rtnl_event, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -198,15 +198,15 @@ static int manager_rtnl_listen(Manager *m) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(m->rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(m->rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (i = reply; i; i = sd_rtnl_message_next(i)) {
|
||||
for (i = reply; i; i = sd_netlink_message_next(i)) {
|
||||
r = manager_process_link(m->rtnl, i, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
@ -323,7 +323,7 @@ void manager_free(Manager *m) {
|
||||
sd_network_monitor_unref(m->network_monitor);
|
||||
|
||||
sd_event_source_unref(m->rtnl_event_source);
|
||||
sd_rtnl_unref(m->rtnl);
|
||||
sd_netlink_unref(m->rtnl);
|
||||
|
||||
sd_event_unref(m->event);
|
||||
free(m);
|
||||
|
@ -22,7 +22,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "sd-event.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "sd-network.h"
|
||||
|
||||
#include "hashmap.h"
|
||||
@ -38,7 +38,7 @@ struct Manager {
|
||||
char **interfaces;
|
||||
char **ignore;
|
||||
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
sd_event_source *rtnl_event_source;
|
||||
|
||||
sd_network_monitor *network_monitor;
|
||||
|
@ -24,7 +24,7 @@
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#include "sd-event.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "sd-bus.h"
|
||||
#include "sd-dhcp-client.h"
|
||||
#include "sd-dhcp-server.h"
|
||||
@ -34,7 +34,7 @@
|
||||
#include "udev.h"
|
||||
#include "sd-lldp.h"
|
||||
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "hashmap.h"
|
||||
#include "list.h"
|
||||
#include "set.h"
|
||||
@ -218,7 +218,7 @@ struct AddressPool {
|
||||
};
|
||||
|
||||
struct Manager {
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
sd_event *event;
|
||||
sd_event_source *bus_retry_event_source;
|
||||
sd_bus *bus;
|
||||
@ -342,8 +342,8 @@ const struct ConfigPerfItem* network_network_gperf_lookup(const char *key, unsig
|
||||
int route_new_static(Network *network, unsigned section, Route **ret);
|
||||
int route_new_dynamic(Route **ret, unsigned char rtm_protocol);
|
||||
void route_free(Route *route);
|
||||
int route_configure(Route *route, Link *link, sd_rtnl_message_handler_t callback);
|
||||
int route_drop(Route *route, Link *link, sd_rtnl_message_handler_t callback);
|
||||
int route_configure(Route *route, Link *link, sd_netlink_message_handler_t callback);
|
||||
int route_drop(Route *route, Link *link, sd_netlink_message_handler_t callback);
|
||||
|
||||
|
||||
DEFINE_TRIVIAL_CLEANUP_FUNC(Route*, route_free);
|
||||
@ -368,9 +368,9 @@ int config_parse_route_scope(const char *unit, const char *filename, unsigned li
|
||||
int address_new_static(Network *network, unsigned section, Address **ret);
|
||||
int address_new_dynamic(Address **ret);
|
||||
void address_free(Address *address);
|
||||
int address_configure(Address *address, Link *link, sd_rtnl_message_handler_t callback);
|
||||
int address_update(Address *address, Link *link, sd_rtnl_message_handler_t callback);
|
||||
int address_drop(Address *address, Link *link, sd_rtnl_message_handler_t callback);
|
||||
int address_configure(Address *address, Link *link, sd_netlink_message_handler_t callback);
|
||||
int address_update(Address *address, Link *link, sd_netlink_message_handler_t callback);
|
||||
int address_drop(Address *address, Link *link, sd_netlink_message_handler_t callback);
|
||||
int address_establish(Address *address, Link *link);
|
||||
int address_release(Address *address, Link *link);
|
||||
bool address_equal(Address *a1, Address *a2);
|
||||
|
@ -3,7 +3,7 @@
|
||||
#include "networkd-netdev-macvlan.h"
|
||||
#include "dhcp6-internal.h"
|
||||
#include "dhcp6-protocol.h"
|
||||
#include "rtnl-internal.h"
|
||||
#include "netlink-internal.h"
|
||||
#include "ethtool-util.h"
|
||||
|
||||
#include "test-tables.h"
|
||||
|
@ -55,7 +55,7 @@
|
||||
#include "sd-daemon.h"
|
||||
#include "sd-bus.h"
|
||||
#include "sd-id128.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "random-util.h"
|
||||
#include "log.h"
|
||||
#include "util.h"
|
||||
@ -75,7 +75,7 @@
|
||||
#include "bus-error.h"
|
||||
#include "ptyfwd.h"
|
||||
#include "env-util.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "udev-util.h"
|
||||
#include "blkid-util.h"
|
||||
#include "gpt.h"
|
||||
@ -1966,7 +1966,7 @@ static int flush_ports(union in_addr_union *exposed) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int expose_ports(sd_rtnl *rtnl, union in_addr_union *exposed) {
|
||||
static int expose_ports(sd_netlink *rtnl, union in_addr_union *exposed) {
|
||||
_cleanup_free_ struct local_address *addresses = NULL;
|
||||
_cleanup_free_ char *pretty = NULL;
|
||||
union in_addr_union new_exposed;
|
||||
@ -2020,7 +2020,7 @@ static int expose_ports(sd_rtnl *rtnl, union in_addr_union *exposed) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int on_address_change(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
|
||||
static int on_address_change(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
|
||||
union in_addr_union *exposed = userdata;
|
||||
|
||||
assert(rtnl);
|
||||
@ -2031,7 +2031,7 @@ static int on_address_change(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int watch_rtnl(sd_event *event, int recv_fd, union in_addr_union *exposed, sd_rtnl **ret) {
|
||||
static int watch_rtnl(sd_event *event, int recv_fd, union in_addr_union *exposed, sd_netlink **ret) {
|
||||
union {
|
||||
struct cmsghdr cmsghdr;
|
||||
uint8_t buf[CMSG_SPACE(sizeof(int))];
|
||||
@ -2041,7 +2041,7 @@ static int watch_rtnl(sd_event *event, int recv_fd, union in_addr_union *exposed
|
||||
.msg_controllen = sizeof(control),
|
||||
};
|
||||
struct cmsghdr *cmsg;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
int fd, r;
|
||||
ssize_t k;
|
||||
|
||||
@ -2062,21 +2062,21 @@ static int watch_rtnl(sd_event *event, int recv_fd, union in_addr_union *exposed
|
||||
assert(cmsg->cmsg_len == CMSG_LEN(sizeof(int)));
|
||||
memcpy(&fd, CMSG_DATA(cmsg), sizeof(int));
|
||||
|
||||
r = sd_rtnl_open_fd(&rtnl, fd);
|
||||
r = sd_netlink_open_fd(&rtnl, fd);
|
||||
if (r < 0) {
|
||||
safe_close(fd);
|
||||
return log_error_errno(r, "Failed to create rtnl object: %m");
|
||||
}
|
||||
|
||||
r = sd_rtnl_add_match(rtnl, RTM_NEWADDR, on_address_change, exposed);
|
||||
r = sd_netlink_add_match(rtnl, RTM_NEWADDR, on_address_change, exposed);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to subscribe to RTM_NEWADDR messages: %m");
|
||||
|
||||
r = sd_rtnl_add_match(rtnl, RTM_DELADDR, on_address_change, exposed);
|
||||
r = sd_netlink_add_match(rtnl, RTM_DELADDR, on_address_change, exposed);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to subscribe to RTM_DELADDR messages: %m");
|
||||
|
||||
r = sd_rtnl_attach_event(rtnl, event, 0);
|
||||
r = sd_netlink_attach_event(rtnl, event, 0);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add to even loop: %m");
|
||||
|
||||
@ -2550,8 +2550,8 @@ static int generate_mac(struct ether_addr *mac, sd_id128_t hash_key, uint64_t id
|
||||
}
|
||||
|
||||
static int setup_veth(pid_t pid, char iface_name[IFNAMSIZ], int *ifi) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
struct ether_addr mac_host, mac_container;
|
||||
int r, i;
|
||||
|
||||
@ -2574,7 +2574,7 @@ static int setup_veth(pid_t pid, char iface_name[IFNAMSIZ], int *ifi) {
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to generate predictable MAC address for host side: %m");
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -2582,51 +2582,51 @@ static int setup_veth(pid_t pid, char iface_name[IFNAMSIZ], int *ifi) {
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to allocate netlink message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, iface_name);
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, iface_name);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface name: %m");
|
||||
|
||||
r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, &mac_host);
|
||||
r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, &mac_host);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink MAC address: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
|
||||
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "veth");
|
||||
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "veth");
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container(m, VETH_INFO_PEER);
|
||||
r = sd_netlink_message_open_container(m, VETH_INFO_PEER);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, "host0");
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, "host0");
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface name: %m");
|
||||
|
||||
r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, &mac_container);
|
||||
r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, &mac_container);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink MAC address: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink namespace field: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_call(rtnl, m, 0, NULL);
|
||||
r = sd_netlink_call(rtnl, m, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add new veth interfaces (host0, %s): %m", iface_name);
|
||||
|
||||
@ -2640,8 +2640,8 @@ static int setup_veth(pid_t pid, char iface_name[IFNAMSIZ], int *ifi) {
|
||||
}
|
||||
|
||||
static int setup_bridge(const char veth_name[], int *ifi) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
int r, bridge;
|
||||
|
||||
if (!arg_private_network)
|
||||
@ -2659,7 +2659,7 @@ static int setup_bridge(const char veth_name[], int *ifi) {
|
||||
|
||||
*ifi = bridge;
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -2671,15 +2671,15 @@ static int setup_bridge(const char veth_name[], int *ifi) {
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to set IFF_UP flag: %m");
|
||||
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, veth_name);
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, veth_name);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface name field: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_MASTER, bridge);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_MASTER, bridge);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink master field: %m");
|
||||
|
||||
r = sd_rtnl_call(rtnl, m, 0, NULL);
|
||||
r = sd_netlink_call(rtnl, m, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add veth interface to bridge: %m");
|
||||
|
||||
@ -2710,7 +2710,7 @@ static int parse_interface(struct udev *udev, const char *name) {
|
||||
|
||||
static int move_network_interfaces(pid_t pid) {
|
||||
_cleanup_udev_unref_ struct udev *udev = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
char **i;
|
||||
int r;
|
||||
|
||||
@ -2720,7 +2720,7 @@ static int move_network_interfaces(pid_t pid) {
|
||||
if (strv_isempty(arg_network_interfaces))
|
||||
return 0;
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -2731,7 +2731,7 @@ static int move_network_interfaces(pid_t pid) {
|
||||
}
|
||||
|
||||
STRV_FOREACH(i, arg_network_interfaces) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
int ifi;
|
||||
|
||||
ifi = parse_interface(udev, *i);
|
||||
@ -2742,11 +2742,11 @@ static int move_network_interfaces(pid_t pid) {
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to allocate netlink message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to append namespace PID to netlink message: %m");
|
||||
|
||||
r = sd_rtnl_call(rtnl, m, 0, NULL);
|
||||
r = sd_netlink_call(rtnl, m, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to move interface %s to namespace: %m", *i);
|
||||
}
|
||||
@ -2756,7 +2756,7 @@ static int move_network_interfaces(pid_t pid) {
|
||||
|
||||
static int setup_macvlan(pid_t pid) {
|
||||
_cleanup_udev_unref_ struct udev *udev = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
unsigned idx = 0;
|
||||
char **i;
|
||||
int r;
|
||||
@ -2767,7 +2767,7 @@ static int setup_macvlan(pid_t pid) {
|
||||
if (strv_isempty(arg_network_macvlan))
|
||||
return 0;
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -2778,7 +2778,7 @@ static int setup_macvlan(pid_t pid) {
|
||||
}
|
||||
|
||||
STRV_FOREACH(i, arg_network_macvlan) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
_cleanup_free_ char *n = NULL;
|
||||
struct ether_addr mac;
|
||||
int ifi;
|
||||
@ -2795,7 +2795,7 @@ static int setup_macvlan(pid_t pid) {
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to allocate netlink message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_LINK, ifi);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_LINK, ifi);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface index: %m");
|
||||
|
||||
@ -2805,39 +2805,39 @@ static int setup_macvlan(pid_t pid) {
|
||||
|
||||
strshorten(n, IFNAMSIZ-1);
|
||||
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, n);
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, n);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface name: %m");
|
||||
|
||||
r = sd_rtnl_message_append_ether_addr(m, IFLA_ADDRESS, &mac);
|
||||
r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, &mac);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink MAC address: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink namespace field: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
|
||||
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "macvlan");
|
||||
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "macvlan");
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_MACVLAN_MODE, MACVLAN_MODE_BRIDGE);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_MACVLAN_MODE, MACVLAN_MODE_BRIDGE);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to append macvlan mode: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_call(rtnl, m, 0, NULL);
|
||||
r = sd_netlink_call(rtnl, m, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add new macvlan interfaces: %m");
|
||||
}
|
||||
@ -2847,7 +2847,7 @@ static int setup_macvlan(pid_t pid) {
|
||||
|
||||
static int setup_ipvlan(pid_t pid) {
|
||||
_cleanup_udev_unref_ struct udev *udev = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
char **i;
|
||||
int r;
|
||||
|
||||
@ -2857,7 +2857,7 @@ static int setup_ipvlan(pid_t pid) {
|
||||
if (strv_isempty(arg_network_ipvlan))
|
||||
return 0;
|
||||
|
||||
r = sd_rtnl_open(&rtnl);
|
||||
r = sd_netlink_open(&rtnl);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to connect to netlink: %m");
|
||||
|
||||
@ -2868,7 +2868,7 @@ static int setup_ipvlan(pid_t pid) {
|
||||
}
|
||||
|
||||
STRV_FOREACH(i, arg_network_ipvlan) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *m = NULL;
|
||||
_cleanup_free_ char *n = NULL;
|
||||
int ifi;
|
||||
|
||||
@ -2880,7 +2880,7 @@ static int setup_ipvlan(pid_t pid) {
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to allocate netlink message: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_LINK, ifi);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_LINK, ifi);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface index: %m");
|
||||
|
||||
@ -2890,35 +2890,35 @@ static int setup_ipvlan(pid_t pid) {
|
||||
|
||||
strshorten(n, IFNAMSIZ-1);
|
||||
|
||||
r = sd_rtnl_message_append_string(m, IFLA_IFNAME, n);
|
||||
r = sd_netlink_message_append_string(m, IFLA_IFNAME, n);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink interface name: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
r = sd_netlink_message_append_u32(m, IFLA_NET_NS_PID, pid);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add netlink namespace field: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container(m, IFLA_LINKINFO);
|
||||
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "ipvlan");
|
||||
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "ipvlan");
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to open netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_append_u16(m, IFLA_IPVLAN_MODE, IPVLAN_MODE_L2);
|
||||
r = sd_netlink_message_append_u16(m, IFLA_IPVLAN_MODE, IPVLAN_MODE_L2);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add ipvlan mode: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_message_close_container(m);
|
||||
r = sd_netlink_message_close_container(m);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to close netlink container: %m");
|
||||
|
||||
r = sd_rtnl_call(rtnl, m, 0, NULL);
|
||||
r = sd_netlink_call(rtnl, m, 0, NULL);
|
||||
if (r < 0)
|
||||
return log_error_errno(r, "Failed to add new ipvlan interfaces: %m");
|
||||
}
|
||||
@ -4681,7 +4681,7 @@ int main(int argc, char *argv[]) {
|
||||
ssize_t l;
|
||||
_cleanup_event_unref_ sd_event *event = NULL;
|
||||
_cleanup_(pty_forward_freep) PTYForward *forward = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
char last_char = 0;
|
||||
|
||||
r = barrier_create(&barrier);
|
||||
|
@ -124,7 +124,7 @@ void link_add_rrs(Link *l, bool force_remove) {
|
||||
link_address_add_rrs(a, force_remove);
|
||||
}
|
||||
|
||||
int link_update_rtnl(Link *l, sd_rtnl_message *m) {
|
||||
int link_update_rtnl(Link *l, sd_netlink_message *m) {
|
||||
const char *n = NULL;
|
||||
int r;
|
||||
|
||||
@ -135,9 +135,9 @@ int link_update_rtnl(Link *l, sd_rtnl_message *m) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
sd_rtnl_message_read_u32(m, IFLA_MTU, &l->mtu);
|
||||
sd_netlink_message_read_u32(m, IFLA_MTU, &l->mtu);
|
||||
|
||||
if (sd_rtnl_message_read_string(m, IFLA_IFNAME, &n) >= 0) {
|
||||
if (sd_netlink_message_read_string(m, IFLA_IFNAME, &n) >= 0) {
|
||||
strncpy(l->name, n, sizeof(l->name)-1);
|
||||
char_array_0(l->name);
|
||||
}
|
||||
@ -522,7 +522,7 @@ fail:
|
||||
log_debug_errno(r, "Failed to update address RRs: %m");
|
||||
}
|
||||
|
||||
int link_address_update_rtnl(LinkAddress *a, sd_rtnl_message *m) {
|
||||
int link_address_update_rtnl(LinkAddress *a, sd_netlink_message *m) {
|
||||
int r;
|
||||
assert(a);
|
||||
assert(m);
|
||||
|
@ -69,7 +69,7 @@ struct Link {
|
||||
|
||||
int link_new(Manager *m, Link **ret, int ifindex);
|
||||
Link *link_free(Link *l);
|
||||
int link_update_rtnl(Link *l, sd_rtnl_message *m);
|
||||
int link_update_rtnl(Link *l, sd_netlink_message *m);
|
||||
int link_update_monitor(Link *l);
|
||||
bool link_relevant(Link *l, int family);
|
||||
LinkAddress* link_find_address(Link *l, int family, const union in_addr_union *in_addr);
|
||||
@ -82,7 +82,7 @@ void link_next_dns_server(Link *l);
|
||||
|
||||
int link_address_new(Link *l, LinkAddress **ret, int family, const union in_addr_union *in_addr);
|
||||
LinkAddress *link_address_free(LinkAddress *a);
|
||||
int link_address_update_rtnl(LinkAddress *a, sd_rtnl_message *m);
|
||||
int link_address_update_rtnl(LinkAddress *a, sd_netlink_message *m);
|
||||
bool link_address_relevant(LinkAddress *l);
|
||||
void link_address_add_rrs(LinkAddress *a, bool force_remove);
|
||||
|
||||
|
@ -24,7 +24,7 @@
|
||||
#include <poll.h>
|
||||
#include <netinet/in.h>
|
||||
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "network-internal.h"
|
||||
#include "socket-util.h"
|
||||
#include "af-list.h"
|
||||
@ -41,7 +41,7 @@
|
||||
|
||||
#define SEND_TIMEOUT_USEC (200 * USEC_PER_MSEC)
|
||||
|
||||
static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
|
||||
static int manager_process_link(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
|
||||
Manager *m = userdata;
|
||||
uint16_t type;
|
||||
Link *l;
|
||||
@ -51,7 +51,7 @@ static int manager_process_link(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userda
|
||||
assert(m);
|
||||
assert(mm);
|
||||
|
||||
r = sd_rtnl_message_get_type(mm, &type);
|
||||
r = sd_netlink_message_get_type(mm, &type);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
@ -102,7 +102,7 @@ fail:
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *userdata) {
|
||||
static int manager_process_address(sd_netlink *rtnl, sd_netlink_message *mm, void *userdata) {
|
||||
Manager *m = userdata;
|
||||
union in_addr_union address;
|
||||
uint16_t type;
|
||||
@ -114,7 +114,7 @@ static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *use
|
||||
assert(mm);
|
||||
assert(m);
|
||||
|
||||
r = sd_rtnl_message_get_type(mm, &type);
|
||||
r = sd_netlink_message_get_type(mm, &type);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
|
||||
@ -133,9 +133,9 @@ static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *use
|
||||
switch (family) {
|
||||
|
||||
case AF_INET:
|
||||
r = sd_rtnl_message_read_in_addr(mm, IFA_LOCAL, &address.in);
|
||||
r = sd_netlink_message_read_in_addr(mm, IFA_LOCAL, &address.in);
|
||||
if (r < 0) {
|
||||
r = sd_rtnl_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
|
||||
r = sd_netlink_message_read_in_addr(mm, IFA_ADDRESS, &address.in);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
}
|
||||
@ -143,9 +143,9 @@ static int manager_process_address(sd_rtnl *rtnl, sd_rtnl_message *mm, void *use
|
||||
break;
|
||||
|
||||
case AF_INET6:
|
||||
r = sd_rtnl_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
|
||||
r = sd_netlink_message_read_in6_addr(mm, IFA_LOCAL, &address.in6);
|
||||
if (r < 0) {
|
||||
r = sd_rtnl_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
|
||||
r = sd_netlink_message_read_in6_addr(mm, IFA_ADDRESS, &address.in6);
|
||||
if (r < 0)
|
||||
goto fail;
|
||||
}
|
||||
@ -188,34 +188,34 @@ fail:
|
||||
}
|
||||
|
||||
static int manager_rtnl_listen(Manager *m) {
|
||||
_cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL;
|
||||
sd_rtnl_message *i;
|
||||
_cleanup_netlink_message_unref_ sd_netlink_message *req = NULL, *reply = NULL;
|
||||
sd_netlink_message *i;
|
||||
int r;
|
||||
|
||||
assert(m);
|
||||
|
||||
/* First, subscribe to interfaces coming and going */
|
||||
r = sd_rtnl_open(&m->rtnl);
|
||||
r = sd_netlink_open(&m->rtnl);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_attach_event(m->rtnl, m->event, 0);
|
||||
r = sd_netlink_attach_event(m->rtnl, m->event, 0);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_NEWLINK, manager_process_link, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_DELLINK, manager_process_link, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_NEWADDR, manager_process_address, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
|
||||
r = sd_netlink_add_match(m->rtnl, RTM_DELADDR, manager_process_address, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
@ -224,37 +224,37 @@ static int manager_rtnl_listen(Manager *m) {
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(m->rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(m->rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (i = reply; i; i = sd_rtnl_message_next(i)) {
|
||||
for (i = reply; i; i = sd_netlink_message_next(i)) {
|
||||
r = manager_process_link(m->rtnl, i, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
}
|
||||
|
||||
req = sd_rtnl_message_unref(req);
|
||||
reply = sd_rtnl_message_unref(reply);
|
||||
req = sd_netlink_message_unref(req);
|
||||
reply = sd_netlink_message_unref(reply);
|
||||
|
||||
/* Finally, enumerate all addresses, too */
|
||||
r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, 0, AF_UNSPEC);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_message_request_dump(req, true);
|
||||
r = sd_netlink_message_request_dump(req, true);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = sd_rtnl_call(m->rtnl, req, 0, &reply);
|
||||
r = sd_netlink_call(m->rtnl, req, 0, &reply);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
for (i = reply; i; i = sd_rtnl_message_next(i)) {
|
||||
for (i = reply; i; i = sd_netlink_message_next(i)) {
|
||||
r = manager_process_address(m->rtnl, i, m);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
@ -23,7 +23,7 @@
|
||||
|
||||
#include "sd-event.h"
|
||||
#include "sd-network.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "list.h"
|
||||
#include "hashmap.h"
|
||||
|
||||
@ -50,7 +50,7 @@ struct Manager {
|
||||
/* Network */
|
||||
Hashmap *links;
|
||||
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
sd_event_source *rtnl_event_source;
|
||||
|
||||
sd_network_monitor *network_monitor;
|
||||
|
151
src/systemd/sd-netlink.h
Normal file
151
src/systemd/sd-netlink.h
Normal file
@ -0,0 +1,151 @@
|
||||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
||||
|
||||
#ifndef foosdnetlinkhfoo
|
||||
#define foosdnetlinkhfoo
|
||||
|
||||
/***
|
||||
This file is part of systemd.
|
||||
|
||||
Copyright 2013 Tom Gundersen <teg@jklm.no>
|
||||
|
||||
systemd 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.
|
||||
|
||||
systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
|
||||
***/
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/ether.h>
|
||||
#include <linux/rtnetlink.h>
|
||||
#include <linux/neighbour.h>
|
||||
|
||||
#include "sd-event.h"
|
||||
#include "_sd-common.h"
|
||||
|
||||
_SD_BEGIN_DECLARATIONS;
|
||||
|
||||
typedef struct sd_netlink sd_netlink;
|
||||
typedef struct sd_netlink_message sd_netlink_message;
|
||||
|
||||
/* callback */
|
||||
|
||||
typedef int (*sd_netlink_message_handler_t)(sd_netlink *nl, sd_netlink_message *m, void *userdata);
|
||||
|
||||
/* bus */
|
||||
int sd_netlink_new_from_netlink(sd_netlink **nl, int fd);
|
||||
int sd_netlink_open(sd_netlink **nl);
|
||||
int sd_netlink_open_fd(sd_netlink **nl, int fd);
|
||||
int sd_netlink_inc_rcvbuf(const sd_netlink *const rtnl, const int size);
|
||||
|
||||
sd_netlink *sd_netlink_ref(sd_netlink *nl);
|
||||
sd_netlink *sd_netlink_unref(sd_netlink *nl);
|
||||
|
||||
int sd_netlink_send(sd_netlink *nl, sd_netlink_message *message, uint32_t *serial);
|
||||
int sd_netlink_call_async(sd_netlink *nl, sd_netlink_message *message,
|
||||
sd_netlink_message_handler_t callback,
|
||||
void *userdata, uint64_t usec, uint32_t *serial);
|
||||
int sd_netlink_call_async_cancel(sd_netlink *nl, uint32_t serial);
|
||||
int sd_netlink_call(sd_netlink *nl, sd_netlink_message *message, uint64_t timeout,
|
||||
sd_netlink_message **reply);
|
||||
|
||||
int sd_netlink_get_events(sd_netlink *nl);
|
||||
int sd_netlink_get_timeout(sd_netlink *nl, uint64_t *timeout);
|
||||
int sd_netlink_process(sd_netlink *nl, sd_netlink_message **ret);
|
||||
int sd_netlink_wait(sd_netlink *nl, uint64_t timeout);
|
||||
int sd_netlink_flush(sd_netlink *nl);
|
||||
|
||||
int sd_netlink_add_match(sd_netlink *nl, uint16_t match, sd_netlink_message_handler_t c, void *userdata);
|
||||
int sd_netlink_remove_match(sd_netlink *nl, uint16_t match, sd_netlink_message_handler_t c, void *userdata);
|
||||
|
||||
int sd_netlink_attach_event(sd_netlink *nl, sd_event *e, int priority);
|
||||
int sd_netlink_detach_event(sd_netlink *nl);
|
||||
|
||||
int sd_netlink_message_append_string(sd_netlink_message *m, unsigned short type, const char *data);
|
||||
int sd_netlink_message_append_u8(sd_netlink_message *m, unsigned short type, uint8_t data);
|
||||
int sd_netlink_message_append_u16(sd_netlink_message *m, unsigned short type, uint16_t data);
|
||||
int sd_netlink_message_append_u32(sd_netlink_message *m, unsigned short type, uint32_t data);
|
||||
int sd_netlink_message_append_in_addr(sd_netlink_message *m, unsigned short type, const struct in_addr *data);
|
||||
int sd_netlink_message_append_in6_addr(sd_netlink_message *m, unsigned short type, const struct in6_addr *data);
|
||||
int sd_netlink_message_append_ether_addr(sd_netlink_message *m, unsigned short type, const struct ether_addr *data);
|
||||
int sd_netlink_message_append_cache_info(sd_netlink_message *m, unsigned short type, const struct ifa_cacheinfo *info);
|
||||
|
||||
int sd_netlink_message_open_container(sd_netlink_message *m, unsigned short type);
|
||||
int sd_netlink_message_open_container_union(sd_netlink_message *m, unsigned short type, const char *key);
|
||||
int sd_netlink_message_close_container(sd_netlink_message *m);
|
||||
|
||||
int sd_netlink_message_read_string(sd_netlink_message *m, unsigned short type, const char **data);
|
||||
int sd_netlink_message_read_u8(sd_netlink_message *m, unsigned short type, uint8_t *data);
|
||||
int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data);
|
||||
int sd_netlink_message_read_u32(sd_netlink_message *m, unsigned short type, uint32_t *data);
|
||||
int sd_netlink_message_read_ether_addr(sd_netlink_message *m, unsigned short type, struct ether_addr *data);
|
||||
int sd_netlink_message_read_cache_info(sd_netlink_message *m, unsigned short type, struct ifa_cacheinfo *info);
|
||||
int sd_netlink_message_read_in_addr(sd_netlink_message *m, unsigned short type, struct in_addr *data);
|
||||
int sd_netlink_message_read_in6_addr(sd_netlink_message *m, unsigned short type, struct in6_addr *data);
|
||||
int sd_netlink_message_enter_container(sd_netlink_message *m, unsigned short type);
|
||||
int sd_netlink_message_exit_container(sd_netlink_message *m);
|
||||
|
||||
int sd_netlink_message_rewind(sd_netlink_message *m);
|
||||
|
||||
sd_netlink_message *sd_netlink_message_next(sd_netlink_message *m);
|
||||
|
||||
sd_netlink_message *sd_netlink_message_ref(sd_netlink_message *m);
|
||||
sd_netlink_message *sd_netlink_message_unref(sd_netlink_message *m);
|
||||
|
||||
int sd_netlink_message_request_dump(sd_netlink_message *m, int dump);
|
||||
int sd_netlink_message_is_error(sd_netlink_message *m);
|
||||
int sd_netlink_message_get_errno(sd_netlink_message *m);
|
||||
int sd_netlink_message_get_type(sd_netlink_message *m, uint16_t *type);
|
||||
int sd_netlink_message_is_broadcast(sd_netlink_message *m);
|
||||
|
||||
/* rtnl */
|
||||
|
||||
int sd_rtnl_message_new_link(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int index);
|
||||
int sd_rtnl_message_new_addr_update(sd_netlink *nl, sd_netlink_message **ret, int index, int family);
|
||||
int sd_rtnl_message_new_addr(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int index, int family);
|
||||
int sd_rtnl_message_new_route(sd_netlink *nl, sd_netlink_message **ret, uint16_t nlmsg_type, int rtm_family, unsigned char rtm_protocol);
|
||||
int sd_rtnl_message_new_neigh(sd_netlink *nl, sd_netlink_message **ret, uint16_t msg_type, int index, int nda_family);
|
||||
|
||||
int sd_netlink_message_get_family(sd_netlink_message *m, int *family);
|
||||
|
||||
int sd_rtnl_message_addr_set_prefixlen(sd_netlink_message *m, unsigned char prefixlen);
|
||||
int sd_rtnl_message_addr_set_scope(sd_netlink_message *m, unsigned char scope);
|
||||
int sd_rtnl_message_addr_set_flags(sd_netlink_message *m, unsigned char flags);
|
||||
int sd_rtnl_message_addr_get_family(sd_netlink_message *m, int *family);
|
||||
int sd_rtnl_message_addr_get_prefixlen(sd_netlink_message *m, unsigned char *prefixlen);
|
||||
int sd_rtnl_message_addr_get_scope(sd_netlink_message *m, unsigned char *scope);
|
||||
int sd_rtnl_message_addr_get_flags(sd_netlink_message *m, unsigned char *flags);
|
||||
int sd_rtnl_message_addr_get_ifindex(sd_netlink_message *m, int *ifindex);
|
||||
|
||||
int sd_rtnl_message_link_set_flags(sd_netlink_message *m, unsigned flags, unsigned change);
|
||||
int sd_rtnl_message_link_set_type(sd_netlink_message *m, unsigned type);
|
||||
int sd_rtnl_message_link_set_family(sd_netlink_message *m, unsigned family);
|
||||
int sd_rtnl_message_link_get_ifindex(sd_netlink_message *m, int *ifindex);
|
||||
int sd_rtnl_message_link_get_flags(sd_netlink_message *m, unsigned *flags);
|
||||
int sd_rtnl_message_link_get_type(sd_netlink_message *m, unsigned *type);
|
||||
|
||||
int sd_rtnl_message_route_set_dst_prefixlen(sd_netlink_message *m, unsigned char prefixlen);
|
||||
int sd_rtnl_message_route_set_src_prefixlen(sd_netlink_message *m, unsigned char prefixlen);
|
||||
int sd_rtnl_message_route_set_scope(sd_netlink_message *m, unsigned char scope);
|
||||
int sd_rtnl_message_route_get_family(sd_netlink_message *m, int *family);
|
||||
int sd_rtnl_message_route_get_dst_prefixlen(sd_netlink_message *m, unsigned char *dst_len);
|
||||
int sd_rtnl_message_route_get_src_prefixlen(sd_netlink_message *m, unsigned char *src_len);
|
||||
|
||||
int sd_rtnl_message_neigh_set_flags(sd_netlink_message *m, uint8_t flags);
|
||||
int sd_rtnl_message_neigh_set_state(sd_netlink_message *m, uint16_t state);
|
||||
int sd_rtnl_message_neigh_get_family(sd_netlink_message *m, int *family);
|
||||
int sd_rtnl_message_neigh_get_ifindex(sd_netlink_message *m, int *family);
|
||||
int sd_rtnl_message_neigh_get_state(sd_netlink_message *m, uint16_t *state);
|
||||
int sd_rtnl_message_neigh_get_flags(sd_netlink_message *m, uint8_t *flags);
|
||||
|
||||
_SD_END_DECLARATIONS;
|
||||
|
||||
#endif
|
@ -1,152 +0,0 @@
|
||||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
||||
|
||||
#ifndef foosdrtnlhfoo
|
||||
#define foosdrtnlhfoo
|
||||
|
||||
/***
|
||||
This file is part of systemd.
|
||||
|
||||
Copyright 2013 Tom Gundersen <teg@jklm.no>
|
||||
|
||||
systemd 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.
|
||||
|
||||
systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
|
||||
***/
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/ether.h>
|
||||
#include <linux/rtnetlink.h>
|
||||
#include <linux/neighbour.h>
|
||||
|
||||
#include "sd-event.h"
|
||||
#include "_sd-common.h"
|
||||
|
||||
_SD_BEGIN_DECLARATIONS;
|
||||
|
||||
typedef struct sd_rtnl sd_rtnl;
|
||||
typedef struct sd_rtnl_message sd_rtnl_message;
|
||||
|
||||
/* callback */
|
||||
|
||||
typedef int (*sd_rtnl_message_handler_t)(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata);
|
||||
|
||||
/* bus */
|
||||
int sd_rtnl_new_from_netlink(sd_rtnl **nl, int fd);
|
||||
int sd_rtnl_open(sd_rtnl **nl);
|
||||
int sd_rtnl_open_fd(sd_rtnl **nl, int fd);
|
||||
int sd_rtnl_inc_rcvbuf(const sd_rtnl *const rtnl, const int size);
|
||||
|
||||
sd_rtnl *sd_rtnl_ref(sd_rtnl *nl);
|
||||
sd_rtnl *sd_rtnl_unref(sd_rtnl *nl);
|
||||
|
||||
int sd_rtnl_send(sd_rtnl *nl, sd_rtnl_message *message, uint32_t *serial);
|
||||
int sd_rtnl_call_async(sd_rtnl *nl, sd_rtnl_message *message,
|
||||
sd_rtnl_message_handler_t callback,
|
||||
void *userdata, uint64_t usec, uint32_t *serial);
|
||||
int sd_rtnl_call_async_cancel(sd_rtnl *nl, uint32_t serial);
|
||||
int sd_rtnl_call(sd_rtnl *nl, sd_rtnl_message *message, uint64_t timeout,
|
||||
sd_rtnl_message **reply);
|
||||
|
||||
int sd_rtnl_get_events(sd_rtnl *nl);
|
||||
int sd_rtnl_get_timeout(sd_rtnl *nl, uint64_t *timeout);
|
||||
int sd_rtnl_process(sd_rtnl *nl, sd_rtnl_message **ret);
|
||||
int sd_rtnl_wait(sd_rtnl *nl, uint64_t timeout);
|
||||
int sd_rtnl_flush(sd_rtnl *nl);
|
||||
|
||||
int sd_rtnl_add_match(sd_rtnl *nl, uint16_t match, sd_rtnl_message_handler_t c, void *userdata);
|
||||
int sd_rtnl_remove_match(sd_rtnl *nl, uint16_t match, sd_rtnl_message_handler_t c, void *userdata);
|
||||
|
||||
int sd_rtnl_attach_event(sd_rtnl *nl, sd_event *e, int priority);
|
||||
int sd_rtnl_detach_event(sd_rtnl *nl);
|
||||
|
||||
/* messages */
|
||||
int sd_rtnl_message_new_link(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t msg_type, int index);
|
||||
int sd_rtnl_message_new_addr_update(sd_rtnl *rtnl, sd_rtnl_message **ret, int index, int family);
|
||||
int sd_rtnl_message_new_addr(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t msg_type, int index,
|
||||
int family);
|
||||
int sd_rtnl_message_new_route(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t nlmsg_type,
|
||||
int rtm_family, unsigned char rtm_protocol);
|
||||
int sd_rtnl_message_new_neigh(sd_rtnl *rtnl, sd_rtnl_message **ret, uint16_t msg_type, int index, int nda_family);
|
||||
|
||||
sd_rtnl_message *sd_rtnl_message_ref(sd_rtnl_message *m);
|
||||
sd_rtnl_message *sd_rtnl_message_unref(sd_rtnl_message *m);
|
||||
|
||||
int sd_rtnl_message_request_dump(sd_rtnl_message *m, int dump);
|
||||
int sd_rtnl_message_is_error(sd_rtnl_message *m);
|
||||
int sd_rtnl_message_get_errno(sd_rtnl_message *m);
|
||||
int sd_rtnl_message_get_type(sd_rtnl_message *m, uint16_t *type);
|
||||
int sd_rtnl_message_is_broadcast(sd_rtnl_message *m);
|
||||
|
||||
int sd_rtnl_message_get_family(sd_rtnl_message *m, int *family);
|
||||
|
||||
int sd_rtnl_message_addr_set_prefixlen(sd_rtnl_message *m, unsigned char prefixlen);
|
||||
int sd_rtnl_message_addr_set_scope(sd_rtnl_message *m, unsigned char scope);
|
||||
int sd_rtnl_message_addr_set_flags(sd_rtnl_message *m, unsigned char flags);
|
||||
int sd_rtnl_message_addr_get_family(sd_rtnl_message *m, int *family);
|
||||
int sd_rtnl_message_addr_get_prefixlen(sd_rtnl_message *m, unsigned char *prefixlen);
|
||||
int sd_rtnl_message_addr_get_scope(sd_rtnl_message *m, unsigned char *scope);
|
||||
int sd_rtnl_message_addr_get_flags(sd_rtnl_message *m, unsigned char *flags);
|
||||
int sd_rtnl_message_addr_get_ifindex(sd_rtnl_message *m, int *ifindex);
|
||||
|
||||
int sd_rtnl_message_link_set_flags(sd_rtnl_message *m, unsigned flags, unsigned change);
|
||||
int sd_rtnl_message_link_set_type(sd_rtnl_message *m, unsigned type);
|
||||
int sd_rtnl_message_link_set_family(sd_rtnl_message *m, unsigned family);
|
||||
int sd_rtnl_message_link_get_ifindex(sd_rtnl_message *m, int *ifindex);
|
||||
int sd_rtnl_message_link_get_flags(sd_rtnl_message *m, unsigned *flags);
|
||||
int sd_rtnl_message_link_get_type(sd_rtnl_message *m, unsigned *type);
|
||||
|
||||
int sd_rtnl_message_route_set_dst_prefixlen(sd_rtnl_message *m, unsigned char prefixlen);
|
||||
int sd_rtnl_message_route_set_src_prefixlen(sd_rtnl_message *m, unsigned char prefixlen);
|
||||
int sd_rtnl_message_route_set_scope(sd_rtnl_message *m, unsigned char scope);
|
||||
int sd_rtnl_message_route_get_family(sd_rtnl_message *m, int *family);
|
||||
int sd_rtnl_message_route_get_dst_prefixlen(sd_rtnl_message *m, unsigned char *dst_len);
|
||||
int sd_rtnl_message_route_get_src_prefixlen(sd_rtnl_message *m, unsigned char *src_len);
|
||||
|
||||
int sd_rtnl_message_neigh_set_flags(sd_rtnl_message *m, uint8_t flags);
|
||||
int sd_rtnl_message_neigh_set_state(sd_rtnl_message *m, uint16_t state);
|
||||
int sd_rtnl_message_neigh_get_family(sd_rtnl_message *m, int *family);
|
||||
int sd_rtnl_message_neigh_get_ifindex(sd_rtnl_message *m, int *family);
|
||||
int sd_rtnl_message_neigh_get_state(sd_rtnl_message *m, uint16_t *state);
|
||||
int sd_rtnl_message_neigh_get_flags(sd_rtnl_message *m, uint8_t *flags);
|
||||
|
||||
int sd_rtnl_message_append_string(sd_rtnl_message *m, unsigned short type, const char *data);
|
||||
int sd_rtnl_message_append_u8(sd_rtnl_message *m, unsigned short type, uint8_t data);
|
||||
int sd_rtnl_message_append_u16(sd_rtnl_message *m, unsigned short type, uint16_t data);
|
||||
int sd_rtnl_message_append_u32(sd_rtnl_message *m, unsigned short type, uint32_t data);
|
||||
int sd_rtnl_message_append_in_addr(sd_rtnl_message *m, unsigned short type, const struct in_addr *data);
|
||||
int sd_rtnl_message_append_in6_addr(sd_rtnl_message *m, unsigned short type, const struct in6_addr *data);
|
||||
int sd_rtnl_message_append_ether_addr(sd_rtnl_message *m, unsigned short type, const struct ether_addr *data);
|
||||
int sd_rtnl_message_append_cache_info(sd_rtnl_message *m, unsigned short type, const struct ifa_cacheinfo *info);
|
||||
|
||||
int sd_rtnl_message_open_container(sd_rtnl_message *m, unsigned short type);
|
||||
int sd_rtnl_message_open_container_union(sd_rtnl_message *m, unsigned short type, const char *key);
|
||||
int sd_rtnl_message_close_container(sd_rtnl_message *m);
|
||||
|
||||
int sd_rtnl_message_read_string(sd_rtnl_message *m, unsigned short type, const char **data);
|
||||
int sd_rtnl_message_read_u8(sd_rtnl_message *m, unsigned short type, uint8_t *data);
|
||||
int sd_rtnl_message_read_u16(sd_rtnl_message *m, unsigned short type, uint16_t *data);
|
||||
int sd_rtnl_message_read_u32(sd_rtnl_message *m, unsigned short type, uint32_t *data);
|
||||
int sd_rtnl_message_read_ether_addr(sd_rtnl_message *m, unsigned short type, struct ether_addr *data);
|
||||
int sd_rtnl_message_read_cache_info(sd_rtnl_message *m, unsigned short type, struct ifa_cacheinfo *info);
|
||||
int sd_rtnl_message_read_in_addr(sd_rtnl_message *m, unsigned short type, struct in_addr *data);
|
||||
int sd_rtnl_message_read_in6_addr(sd_rtnl_message *m, unsigned short type, struct in6_addr *data);
|
||||
int sd_rtnl_message_enter_container(sd_rtnl_message *m, unsigned short type);
|
||||
int sd_rtnl_message_exit_container(sd_rtnl_message *m);
|
||||
|
||||
int sd_rtnl_message_rewind(sd_rtnl_message *m);
|
||||
|
||||
sd_rtnl_message *sd_rtnl_message_next(sd_rtnl_message *m);
|
||||
|
||||
_SD_END_DECLARATIONS;
|
||||
|
||||
#endif
|
@ -27,7 +27,7 @@
|
||||
|
||||
#include "util.h"
|
||||
#include "macro.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
|
||||
static int load_module(const char *mod_name) {
|
||||
struct kmod_ctx *ctx;
|
||||
@ -62,9 +62,9 @@ static int load_module(const char *mod_name) {
|
||||
return r;
|
||||
}
|
||||
|
||||
static int test_tunnel_configure(sd_rtnl *rtnl) {
|
||||
static int test_tunnel_configure(sd_netlink *rtnl) {
|
||||
int r;
|
||||
sd_rtnl_message *m, *n;
|
||||
sd_netlink_message *m, *n;
|
||||
struct in_addr local, remote;
|
||||
|
||||
/* skip test if module cannot be loaded */
|
||||
@ -79,25 +79,25 @@ static int test_tunnel_configure(sd_rtnl *rtnl) {
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0) >= 0);
|
||||
assert_se(m);
|
||||
|
||||
assert_se(sd_rtnl_message_append_string(m, IFLA_IFNAME, "ipip-tunnel") >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_MTU, 1234)>= 0);
|
||||
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, "ipip-tunnel") >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_MTU, 1234)>= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_open_container(m, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_netlink_message_open_container(m, IFLA_LINKINFO) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_open_container_union(m, IFLA_INFO_DATA, "ipip") >= 0);
|
||||
assert_se(sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "ipip") >= 0);
|
||||
|
||||
inet_pton(AF_INET, "192.168.21.1", &local.s_addr);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_IPTUN_LOCAL, local.s_addr) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_IPTUN_LOCAL, local.s_addr) >= 0);
|
||||
|
||||
inet_pton(AF_INET, "192.168.21.2", &remote.s_addr);
|
||||
assert_se(sd_rtnl_message_append_u32(m, IFLA_IPTUN_REMOTE, remote.s_addr) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(m, IFLA_IPTUN_REMOTE, remote.s_addr) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(m) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, m, -1, 0) == 1);
|
||||
assert_se(sd_netlink_call(rtnl, m, -1, 0) == 1);
|
||||
|
||||
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
|
||||
assert_se((m = sd_netlink_message_unref(m)) == NULL);
|
||||
|
||||
r = load_module("sit");
|
||||
if(r < 0)
|
||||
@ -107,41 +107,41 @@ static int test_tunnel_configure(sd_rtnl *rtnl) {
|
||||
assert_se(sd_rtnl_message_new_link(rtnl, &n, RTM_NEWLINK, 0) >= 0);
|
||||
assert_se(n);
|
||||
|
||||
assert_se(sd_rtnl_message_append_string(n, IFLA_IFNAME, "sit-tunnel") >= 0);
|
||||
assert_se(sd_rtnl_message_append_u32(n, IFLA_MTU, 1234)>= 0);
|
||||
assert_se(sd_netlink_message_append_string(n, IFLA_IFNAME, "sit-tunnel") >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(n, IFLA_MTU, 1234)>= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_open_container(n, IFLA_LINKINFO) >= 0);
|
||||
assert_se(sd_netlink_message_open_container(n, IFLA_LINKINFO) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_open_container_union(n, IFLA_INFO_DATA, "sit") >= 0);
|
||||
assert_se(sd_netlink_message_open_container_union(n, IFLA_INFO_DATA, "sit") >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_append_u8(n, IFLA_IPTUN_PROTO, IPPROTO_IPIP) >= 0);
|
||||
assert_se(sd_netlink_message_append_u8(n, IFLA_IPTUN_PROTO, IPPROTO_IPIP) >= 0);
|
||||
|
||||
inet_pton(AF_INET, "192.168.21.3", &local.s_addr);
|
||||
assert_se(sd_rtnl_message_append_u32(n, IFLA_IPTUN_LOCAL, local.s_addr) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(n, IFLA_IPTUN_LOCAL, local.s_addr) >= 0);
|
||||
|
||||
inet_pton(AF_INET, "192.168.21.4", &remote.s_addr);
|
||||
assert_se(sd_rtnl_message_append_u32(n, IFLA_IPTUN_REMOTE, remote.s_addr) >= 0);
|
||||
assert_se(sd_netlink_message_append_u32(n, IFLA_IPTUN_REMOTE, remote.s_addr) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_message_close_container(n) >= 0);
|
||||
assert_se(sd_rtnl_message_close_container(n) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(n) >= 0);
|
||||
assert_se(sd_netlink_message_close_container(n) >= 0);
|
||||
|
||||
assert_se(sd_rtnl_call(rtnl, n, -1, 0) == 1);
|
||||
assert_se(sd_netlink_call(rtnl, n, -1, 0) == 1);
|
||||
|
||||
assert_se((m = sd_rtnl_message_unref(n)) == NULL);
|
||||
assert_se((m = sd_netlink_message_unref(n)) == NULL);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
int r;
|
||||
|
||||
assert_se(sd_rtnl_open(&rtnl) >= 0);
|
||||
assert_se(sd_netlink_open(&rtnl) >= 0);
|
||||
assert_se(rtnl);
|
||||
|
||||
r = test_tunnel_configure(rtnl);
|
||||
|
||||
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
|
||||
assert_se((rtnl = sd_netlink_unref(rtnl)) == NULL);
|
||||
|
||||
return r;
|
||||
}
|
@ -28,14 +28,14 @@
|
||||
#include "ethtool-util.h"
|
||||
|
||||
#include "libudev-private.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "util.h"
|
||||
#include "log.h"
|
||||
#include "strv.h"
|
||||
#include "path-util.h"
|
||||
#include "conf-parser.h"
|
||||
#include "conf-files.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "network-internal.h"
|
||||
#include "random-util.h"
|
||||
|
||||
@ -46,7 +46,7 @@ struct link_config_ctx {
|
||||
|
||||
bool enable_name_policy;
|
||||
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
|
||||
usec_t link_dirs_ts_usec;
|
||||
};
|
||||
@ -103,7 +103,7 @@ void link_config_ctx_free(link_config_ctx *ctx) {
|
||||
|
||||
safe_close(ctx->ethtool_fd);
|
||||
|
||||
sd_rtnl_unref(ctx->rtnl);
|
||||
sd_netlink_unref(ctx->rtnl);
|
||||
|
||||
link_configs_free(ctx);
|
||||
|
||||
|
@ -30,7 +30,7 @@
|
||||
#include <sys/wait.h>
|
||||
#include <sys/signalfd.h>
|
||||
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "event-util.h"
|
||||
#include "formats-util.h"
|
||||
#include "process-util.h"
|
||||
@ -62,7 +62,7 @@ struct udev_event *udev_event_new(struct udev_device *dev) {
|
||||
void udev_event_unref(struct udev_event *event) {
|
||||
if (event == NULL)
|
||||
return;
|
||||
sd_rtnl_unref(event->rtnl);
|
||||
sd_netlink_unref(event->rtnl);
|
||||
udev_list_cleanup(&event->run_list);
|
||||
udev_list_cleanup(&event->seclabel_list);
|
||||
free(event->program_result);
|
||||
|
@ -22,7 +22,7 @@
|
||||
#include <sys/param.h>
|
||||
|
||||
#include "macro.h"
|
||||
#include "sd-rtnl.h"
|
||||
#include "sd-netlink.h"
|
||||
#include "libudev.h"
|
||||
#include "libudev-private.h"
|
||||
#include "util.h"
|
||||
@ -43,7 +43,7 @@ struct udev_event {
|
||||
struct udev_list run_list;
|
||||
int exec_delay;
|
||||
usec_t birth_usec;
|
||||
sd_rtnl *rtnl;
|
||||
sd_netlink *rtnl;
|
||||
unsigned int builtin_run;
|
||||
unsigned int builtin_ret;
|
||||
bool inotify_watch;
|
||||
|
@ -45,7 +45,7 @@
|
||||
|
||||
#include "signal-util.h"
|
||||
#include "event-util.h"
|
||||
#include "rtnl-util.h"
|
||||
#include "netlink-util.h"
|
||||
#include "cgroup-util.h"
|
||||
#include "process-util.h"
|
||||
#include "dev-setup.h"
|
||||
@ -339,7 +339,7 @@ static void worker_spawn(Manager *manager, struct event *event) {
|
||||
switch (pid) {
|
||||
case 0: {
|
||||
struct udev_device *dev = NULL;
|
||||
_cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
|
||||
_cleanup_netlink_unref_ sd_netlink *rtnl = NULL;
|
||||
int fd_monitor;
|
||||
_cleanup_close_ int fd_signal = -1, fd_ep = -1;
|
||||
struct epoll_event ep_signal = { .events = EPOLLIN };
|
||||
@ -455,7 +455,7 @@ static void worker_spawn(Manager *manager, struct event *event) {
|
||||
|
||||
if (udev_event->rtnl)
|
||||
/* in case rtnl was initialized */
|
||||
rtnl = sd_rtnl_ref(udev_event->rtnl);
|
||||
rtnl = sd_netlink_ref(udev_event->rtnl);
|
||||
|
||||
/* apply/restore inotify watch */
|
||||
if (udev_event->inotify_watch) {
|
||||
|
Loading…
Reference in New Issue
Block a user