***/
#include <netinet/ether.h>
+#include <net/if.h>
#include "util.h"
#include "macro.h"
static void test_link_configure(sd_rtnl *rtnl, int ifindex) {
_cleanup_rtnl_message_unref_ sd_rtnl_message *message;
const char *mac = "98:fe:94:3f:c6:18", *name = "test";
+ char buffer[ETHER_ADDR_TO_STRING_MAX];
unsigned int mtu = 1450, mtu_out;
- char *name_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(streq(name, name_out));
assert_se(sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &mac_out) >= 0);
- assert_se(streq(mac, ether_ntoa(&mac_out)));
+ 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);
sd_rtnl_message *m;
sd_rtnl_message *r;
unsigned int mtu = 1500;
- char *str_data;
+ const char *str_data;
uint8_t u8_data;
uint32_t u32_data;
struct ether_addr eth_data;
sd_rtnl_message *m;
sd_rtnl_message *r;
struct in_addr in_data;
- char *label;
+ 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_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);
static void test_route(void) {
_cleanup_rtnl_message_unref_ sd_rtnl_message *req;
- struct rtmsg *rtm;
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);
+ r = sd_rtnl_message_new_route(NULL, &req, RTM_NEWROUTE, AF_INET, RTPROT_STATIC);
if (r < 0) {
- log_error("Could not create RTM_NEWROUTE message: %s", strerror(-r));
+ log_error_errno(r, "Could not create RTM_NEWROUTE message: %m");
return;
}
r = sd_rtnl_message_append_in_addr(req, RTA_GATEWAY, &addr);
if (r < 0) {
- log_error("Could not append RTA_GATEWAY attribute: %s", strerror(-r));
+ 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("Could not append RTA_OIF attribute: %s", strerror(-r));
+ log_error_errno(r, "Could not append RTA_OIF attribute: %m");
return;
}
assert_se(sd_rtnl_message_read_u32(req, RTA_OIF, &u32_data) >= 0);
assert_se(u32_data == index);
- rtm = NLMSG_DATA(req->hdr);
- r = rtnl_message_parse(req,
- &req->rta_offset_tb,
- &req->rta_tb_size,
- RTA_MAX,
- RTM_RTA(rtm),
- RTM_PAYLOAD(req->hdr));
-
- assert_se(sd_rtnl_message_read_u32(req, RTA_GATEWAY, &u32_data) == 0);
- assert_se(sd_rtnl_message_read_u32(req, RTA_OIF, &u32_data) == 0);
-
assert_se((req = sd_rtnl_message_unref(req)) == NULL);
}
}
static int link_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
- char *ifname = userdata, *data;
+ char *ifname = userdata;
+ const char *data;
assert_se(rtnl);
assert_se(m);
r = sd_rtnl_message_get_errno(m);
- log_info("%d left in pipe. got reply: %s", *counter, strerror(-r));
+ log_info_errno(r, "%d left in pipe. got reply: %m", *counter);
assert_se(r >= 0);
static void test_container(void) {
_cleanup_rtnl_message_unref_ sd_rtnl_message *m = NULL;
- struct ifinfomsg *ifi;
uint16_t u16_data;
uint32_t u32_data;
- char *string_data;
- int r;
+ 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(m, IFLA_LINKINFO) == -ENOTSUP);
- assert_se(sd_rtnl_message_append_string(m, IFLA_INFO_KIND, "vlan") >= 0);
- assert_se(sd_rtnl_message_open_container(m, IFLA_INFO_DATA) >= 0);
- assert_se(sd_rtnl_message_open_container(m, IFLA_INFO_DATA) == -ENOTSUP);
+ 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(streq("vlan", string_data));
assert_se(sd_rtnl_message_exit_container(m) >= 0);
- ifi = NLMSG_DATA(m->hdr);
- r = rtnl_message_parse(m,
- &m->rta_offset_tb,
- &m->rta_tb_size,
- IFLA_MAX,
- IFLA_RTA(ifi),
- IFLA_PAYLOAD(m->hdr));
- if(r < 0)
- return;
-
- assert_se(sd_rtnl_message_read_u32(m, IFLA_LINKINFO, &u32_data) == 0);
+ assert_se(sd_rtnl_message_read_u32(m, IFLA_LINKINFO, &u32_data) < 0);
assert_se(sd_rtnl_message_exit_container(m) == -EINVAL);
}
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);
+ }
+}
+
int main(void) {
sd_rtnl *rtnl;
sd_rtnl_message *m;
sd_rtnl_message *r;
- char *string_data;
+ const char *string_data;
int if_loopback;
uint16_t type;
test_link_configure(rtnl, if_loopback);
+ test_get_addresses(rtnl);
+
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
assert_se(m);